searchgui.py

来自「Ubuntu packages of security software。 相」· Python 代码 · 共 955 行 · 第 1/3 页

        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)
        

    keyword = property(get_keyword, set_keyword)
    profile = property(get_profile, set_profile)
    option = property(get_option, set_option)
    target = property(get_target, set_target)
    mac = property(get_mac, set_mac)
    ipv4 = property(get_ipv4, set_ipv4)
    ipv6 = property(get_ipv6, set_ipv6)
    port = property(get_port, set_port)
    port_open = property(get_port_open, set_port_open)
    port_filtered = property(get_port_filtered, set_port_filtered)
    port_closed = property(get_port_closed, set_port_closed)
    service = property(get_service, set_service)
    product = property(get_product, set_product)
    osclass = property(get_osclass, set_osclass)
    osmatch = property(get_osmatch, set_osmatch)
    directory = property(get_directory, set_directory)
    file_extension = property(get_file_extension, set_file_extension)
    save_time = property(get_save_time, set_save_time)
    save = property(get_save, set_save)
    search_db = property(get_search_db, set_search_db)
    selected_results = property(get_selected_results)

class Date(gtk.HBox, object):
    def __init__(self):
        gtk.HBox.__init__(self)
        self._create_widgets()
        self._connect_widgets()
        self._pack_widgets()

        self.date = localtime()[:3]

    def _create_widgets(self):
        t = localtime()
        self.date_button = HIGButton()
        self.date_sep = gtk.Label(", ")
        self.hour = gtk.SpinButton(gtk.Adjustment(value=t[3],
                                                  lower=0,
                                                  upper=23,
                                                  step_incr=1), 1)
        self.hour_sep = gtk.Label(":")
        self.minute = gtk.SpinButton(gtk.Adjustment(value=t[4],
                                                  lower=0,
                                                  upper=59,
                                                  step_incr=1), 1)

    def _connect_widgets(self):
        self.date_button.connect("clicked", self.show_calendar)

    def _pack_widgets(self):
        self.hour.set_width_chars(2)
        self.minute.set_width_chars(2)
        
        self.pack_start(self.date_button, False, False)
        self.pack_start(self.date_sep, False, False)
        self.pack_start(self.hour, False, False)
        self.pack_start(self.hour_sep, False, False)
        self.pack_start(self.minute, False, False)

    def show_calendar(self, widget):
        calendar = DateCalendar()
        calendar.connect_calendar(self.update_button)
        calendar.show_all()

    def update_button(self, widget):
        date = list(widget.get_date())
        date[1] += 1 # Add 1 to month, because calendar date is zero-based
        self.date = tuple(date)

    def set_date(self, date):
        # Localtime Format: (year, month, day)
        self.date_button.set_label("%02d %s %04d" % (date[2], months[date[1]][:3], date[0]))
        self._date = date

    def get_date(self):
        return self._date

    def get_time(self):
        return (self.hour.get_value_as_int(), self.minute.get_value_as_int())

    def set_time(self, time):
        print time
        if type(time) == type([]):
            self.hour.set_value(time[0])
            self.minute.set_value(time[1])
        elif type(time) in StringTypes:
            time = time.split(";")
            self.hour.set_value(time[0])
            self.minute.set_value(time[1])

    date = property(get_date, set_date)
    time = property(get_time, set_time)
    _date = localtime()[:3]

class DateCalendar(gtk.Window, object):
    def __init__(self):
        gtk.Window.__init__(self, gtk.WINDOW_POPUP)
        self.set_position(gtk.WIN_POS_MOUSE)
        
        self.calendar = gtk.Calendar()
        self.add(self.calendar)

    def connect_calendar(self, method):
        self.calendar.connect("day-selected-double-click", self.kill_calendar, method)

    def kill_calendar(self, widget, method):
        method(widget)
        self.destroy()

class DateRange(gtk.HBox, object):
    def __init__(self):
        gtk.HBox.__init__(self)

        self._create_widgets()
        self._pack_widgets()

    def _create_widgets(self):
        self.label2 = gtk.Label("<b> %s </b>" % _("/"))
        
        self.entry1 = Date()
        self.entry2 = Date()

    def _pack_widgets(self):
        self.label2.set_use_markup(True)

        self.pack_start(self.entry1, False, False)
        self.pack_start(self.label2, False, False)
        self.pack_start(self.entry2, False, False)
        
    def get_start(self):
        return self.entry1.date + self.entry1.time

    def set_start(self, start):
        self.entry1.date = start[:3]
        self.entry1.time = start[3:]

    def get_end(self):
        return self.entry2.date +self.entry2.time

    def set_end(self, end):
        self.entry2.date = end[:3]
        self.entry2.time = end[3:]

    start = property(get_start, set_start)
    end = property(get_end, set_end)

class PortState(gtk.VBox, object):
    def __init__(self):
        gtk.VBox.__init__(self)
        self.open_check = gtk.CheckButton(_("Open"))
        self.filtered_check = gtk.CheckButton(_("Filtered"))
        self.closed_check = gtk.CheckButton(_("Closed"))

        self.pack_start(self.open_check, False, False)
        self.pack_start(self.filtered_check, False, False)
        self.pack_start(self.closed_check, False, False)

    def get_open(self):
        return self.open_check.get_active()

    def set_open(self, open):
        self.open_check.set_active(open)

    def get_filtered(self):
        return self.filtered_check.get_active()

    def set_filtered(self, filtered):
        self.filtered_check.set_active(filtered)

    def get_closed(self):
        return self.closed_check.get_active()

    def set_closed(self, closed):
        self.closed_check.set_active(closed)


    open = property(get_open, set_open)
    filtered = property(get_filtered, set_filtered)
    closed = property(get_closed, set_closed)

class PathEntry(HIGHBox, object):
    def __init__(self):
        HIGHBox.__init__(self)
        self.entry = gtk.Entry()
        self.button = HIGButton(stock=gtk.STOCK_OPEN)

        self.entry.set_width_chars(20)
        self.button.connect("clicked", self.open_dialog)
        
        self._pack_expand_fill(self.entry)
        self._pack_noexpand_nofill(self.button)

    def connect_entry_change(self, method):
        self.entry.connect("focus-out-event", method)

    def open_dialog(self, widget):
        dialog = DirectoryChooserDialog(title=_("Choose the path to search in"))
        dialog.run()
        self.path = dialog.get_filename()
        self.entry.grab_focus()
        dialog.destroy()

    def get_path(self):
        return self.entry.get_text()

    def set_path(self, path):
        self.entry.set_text(path)

    path = property(get_path, set_path)

class SaveTime(HIGHBox, object):
    def __init__(self):
        HIGHBox.__init__(self)
        self.entry = gtk.SpinButton(gtk.Adjustment(value=30,
                                                   lower=0,
                                                   upper=9999,
                                                   step_incr=1), 1)
        self.time_list = gtk.ListStore(str)
        self.time_combo = gtk.ComboBoxEntry(self.time_list, 0)

        self.entry.set_width_chars(4)

        for i in SearchConfig().time_list.keys():
            self.time_list.append([i])

        self._pack_noexpand_nofill(self.entry)
        self._pack_expand_fill(self.time_combo)

    def get_time(self):
        # Format: [self.entry.get_text(), self.time_combo.child.get_text()]
        # Format: ["10", "days"]
        return [self.entry.get_text(), self.time_combo.child.get_text()]

    def connect_entry_change(self, method):
        self.entry.connect("focus-out-event", method)
        self.time_combo.connect("changed", method)

    def set_time(self, time):
        self.entry.set_value(int(time[0]))
        self.time_combo.child.set_text(time[1])

    time = property(get_time, set_time)

if __name__ == "__main__":
    def quit(x, y):
        print "keyword", s.keyword
        print "profile", s.profile
        print "option", s.option
        print "target", s.target
        print "mac", s.mac
        print "ipv4", s.ipv4
        print "ipv6", s.ipv6
        print "port", s.port
        print "port_open", s.port_open
        print "port_filtered", s.port_filtered
        print "port_closed", s.port_closed
        print "service", s.service
        print "product", s.product
        print "osclass", s.osclass
        print "osmatch", s.osmatch
        print "directory", s.directory
        print "file_extension", s.file_extension
        print "save_time", s.save_time
        print "save", s.save
        print "search_db", s.search_db
        print "selected_results", s.selected_results
            
        gtk.main_quit()


    s = SearchGUI()
    s.keyword = "Testing Keyword"
    s.profile = "Testing Profile"
    s.option = "Testing Option"
    s.target = "www.microsoft.com"
    s.mac = "MAC Address"
    s.ipv4 = "IPv4 Address"
    s.ipv6 = "IPv6 Address"
    s.port = "20"
    s.port_open = True
    s.port_filtered = True
    s.port_closed = True
    s.service = "ssh"
    s.osclass = "Any class"
    s.osmatch = "Any match"
    s.product = "OpenSSH"
    s.directory = "/home/adriano"
    s.file_extension = "usr;txt;nmap"
    s.save_time = ["30", "Years"]
    s.save = True
    s.search_db = True
    
    w = gtk.Window()
    w.set_size_request(700, 420)
    w.connect("delete-event", quit)
    w.add(s)
    
    w.show_all()

    gtk.main()