def __init__(self, w3af):
super(URLsGraph, self).__init__()
self.w3af = w3af
self.toolbox = gtk.HBox()
b = entries.SemiStockButton("", gtk.STOCK_ZOOM_IN, 'Zoom In')
b.connect("clicked", self._zoom, "in")
self.toolbox.pack_start(b, False, False)
b = entries.SemiStockButton("", gtk.STOCK_ZOOM_OUT, 'Zoom Out')
b.connect("clicked", self._zoom, "out")
self.toolbox.pack_start(b, False, False)
b = entries.SemiStockButton("", gtk.STOCK_ZOOM_FIT, 'Zoom Fit')
b.connect("clicked", self._zoom, "fit")
self.toolbox.pack_start(b, False, False)
b = entries.SemiStockButton("", gtk.STOCK_ZOOM_100, 'Zoom 100%')
b.connect("clicked", self._zoom, "100")
self.toolbox.pack_start(b, False, False)
self.pack_start(self.toolbox, False, False)
self.toolbox.set_sensitive(False)
# no graph yet
self.widget = gtk.Label(_("No info yet"))
self.widget.set_sensitive(False)
self.nodos_code = []
self._somethingnew = False
self.pack_start(self.widget)
self.show_all()
gobject.timeout_add(500, self._draw_start)
def __init__(self, w3af):
super(EncodeDecode, self).__init__(w3af, "encodedecode",
_("w3af - Encode / Decode"),
"Encode_and_Decode")
self.w3af = w3af
# Splitted panes
vpan = entries.RememberingVPaned(w3af, "pane-encodedecode")
# Upper pane
vbox = gtk.VBox()
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.paneup = SimpleTextView()
sw.add(self.paneup)
vbox.pack_start(sw, True, True, padding=5)
# Middle buttons, left
hbox = gtk.HBox()
cb = gtk.combo_box_new_text()
for (lab, fnc) in _butNameFunc_enc:
cb.append_text(lab)
b = gtk.Button(lab)
cb.set_active(0)
hbox.pack_start(cb, False, False, padding=10)
b = entries.SemiStockButton("Encode", gtk.STOCK_GO_DOWN,
_("Encode the upper text"))
b.connect("clicked", self._encode, cb)
hbox.pack_start(b, False, False)
# Middle buttons, rigth
cb = gtk.combo_box_new_text()
for (lab, fnc) in _butNameFunc_dec:
cb.append_text(lab)
b = gtk.Button(lab)
cb.set_active(0)
b = entries.SemiStockButton("Decode", gtk.STOCK_GO_UP,
_("Decode the lower text"))
hbox.pack_end(b, False, False, padding=10)
b.connect("clicked", self._decode, cb)
hbox.pack_end(cb, False, False)
vbox.pack_start(hbox, False, False, padding=5)
vpan.pack1(vbox)
# Lower pane
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.panedn = SimpleTextView()
sw.add(self.panedn)
vpan.pack2(sw)
self.vbox.pack_start(vpan, padding=10)
self.show_all()
def __init__(self, mainwin, w3af):
super(PluginConfigBody, self).__init__()
self.w3af = w3af
targetbox = gtk.HBox()
# label
lab = gtk.Label(_("Target:"))
targetbox.pack_start(lab, expand=False, fill=False, padding=5)
# entry
histfile = os.path.join(get_home_dir(), "urlhistory.pkl")
hint = _("http://target.example/")
self.target = entries.ValidatedAdvisedEntry(
hint,
mainwin.scanok.change,
histfile,
alertmodif=mainwin.profile_changed)
self.target.connect("activate", mainwin._scan_director)
self.target.connect("activate", self.target.insert_url)
targetbox.pack_start(self.target, expand=True, fill=True, padding=5)
# start/stop button
startstop = entries.SemiStockButton(_("Start"), gtk.STOCK_MEDIA_PLAY,
_("Start scan"))
startstop.set_sensitive(False)
startstop.connect("clicked", mainwin._scan_director)
startstop.connect("clicked", self.target.insert_url)
mainwin.startstopbtns.addWidget(startstop)
targetbox.pack_start(startstop, expand=False, fill=False, padding=5)
# advanced config
advbut = entries.SemiStockButton(
"", gtk.STOCK_PREFERENCES, _("Advanced Target URL configuration"))
advbut.connect("clicked", self._advanced_target)
targetbox.pack_start(advbut, expand=False, fill=False, padding=5)
targetbox.show_all()
self.pack_start(targetbox, expand=False, fill=False)
# the pan with all the configs
self.pan = self._buildpan()
self.pack_start(self.pan, padding=5)
# key binding
self.key_l = gtk.gdk.keyval_from_name("l")
mainwin.window.connect("key-press-event", self._key)
self.show()
def _buildExplVuln(self):
"""The pane with the exploit list and vulnerabilities tree."""
hpan = entries.RememberingHPaned(self.w3af, "pane-epxlvuln", 300)
vpan = entries.RememberingVPaned(self.w3af, "pane-expl-desc", 300)
# left-bottom
plugin_cfg = ConfigPanel()
# left-top
exploitlist = ExploitTree(self.w3af, plugin_cfg)
scrollwin1 = gtk.ScrolledWindow()
scrollwin1.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrollwin1.add_with_viewport(exploitlist)
scrollwin1.show()
vpan.pack1(scrollwin1)
vpan.pack2(plugin_cfg)
vpan.show()
# Right
vuln_vbox = gtk.VBox()
interac = VulnerabList(self.w3af, exploitlist)
exploitlist.vulnerabs = interac
scrollwin2 = gtk.ScrolledWindow()
scrollwin2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrollwin2.add_with_viewport(interac)
scrollwin2.show()
add_button = entries.SemiStockButton(
"Add...", gtk.STOCK_ADD, "Manually add a new vulnerability")
add_button.show()
add_button.connect("clicked", self.add_vuln)
vuln_vbox.pack_start(scrollwin2)
vuln_vbox.pack_start(add_button, False, False)
vuln_vbox.show()
# pack it all and show
hpan.pack1(vpan)
hpan.pack2(vuln_vbox)
hpan.show()
return hpan
def __init__(self, w3af, initial_request=None):
super(ManualRequests,
self).__init__(w3af, "manualreq", "w3af - Manual Requests",
"Manual_Requests")
self.w3af = w3af
#
# Toolbar
#
self.send_but = entries.SemiStockButton(_("Send"),
gtk.STOCK_MEDIA_PLAY,
_("Send HTTP request"))
self.send_but.connect("clicked", self._send)
self.send_but.show()
# Fix content length checkbox
self._fix_content_len_cb = gtk.CheckButton('Fix content length header')
self._fix_content_len_cb.set_active(True)
self._fix_content_len_cb.show()
# request-response viewer
self.reqresp = reqResViewer.reqResViewer(w3af,
[self.send_but.set_sensitive],
withManual=False,
editableRequest=True)
self.reqresp.response.set_sensitive(False)
self.vbox.pack_start(self.reqresp, True, True)
self.vbox.pack_start(self._fix_content_len_cb, False, False)
self.vbox.pack_start(self.send_but, False, False)
# Add a default request
if initial_request is None:
self.reqresp.request.show_raw(MANUAL_REQUEST_EXAMPLE, '')
else:
(initialUp, initialDn) = initial_request
self.reqresp.request.show_raw(initialUp, initialDn)
# Show all!
self.show()
def __init__(self):
gtk.VBox.__init__(self)
# up row buttons
upbox = gtk.HBox()
self.filters = {}
def make_but(label, signal, initial):
but = gtk.CheckButton(label)
but.set_active(initial)
but.connect("clicked", self.type_filter, signal)
self.filters[signal] = initial
upbox.pack_start(but, False, False)
make_but(_("Vulnerabilities"), "vulnerability", True)
make_but(_("Information"), "information", True)
make_but(_("Error"), "error", True)
search = entries.SemiStockButton(_("Search"), gtk.STOCK_FIND,
_("Search in the text"))
upbox.pack_end(search, False, False)
upbox.show_all()
self.pack_start(upbox, expand=False, fill=False)
# the scrolling lines
sw_mess = gtk.ScrolledWindow()
sw_mess.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
newfilter = [k for k, v in self.filters.items() if v]
self.sclines = _LineScroller(sw_mess.get_vscrollbar(),
newfilter, self.filters.keys())
sw_mess.add(self.sclines)
sw_mess.show()
self.pack_start(sw_mess, expand=True, fill=True)
Searchable.__init__(self, self.sclines)
search.connect("clicked", self.show_search)
self.show()
self.queue_draw()
def _makeTable(self, options, prop):
"""Creates the table in which the options are shown.
:param options: The options to show
:param prop: The propagation function for this options
:return: The created table
For each row, it will put:
- the option label
- the configurable widget (textentry, checkbox, etc.)
- an optional button to get more help (if the help is available)
Also, the configurable widget gets a tooltip for a small description.
"""
table = entries.EasyTable(len(options), 3)
for _, opt in enumerate(options):
titl = gtk.Label(opt.get_name())
titl.set_alignment(0.0, 0.5)
input_widget_klass = entries.wrapperWidgets.get(
opt.get_type(), entries.TextInput)
widg = input_widget_klass(self._changedWidget, opt)
opt.widg = widg
widg.set_tooltip_text(opt.get_desc())
if opt.get_help():
helpbtn = entries.SemiStockButton("", gtk.STOCK_INFO)
cleanhelp = helpers.clean_description(opt.get_help())
helpbtn.connect("clicked", self._showHelp, cleanhelp)
else:
helpbtn = None
table.auto_add_row(titl, widg, helpbtn)
self.widgets_status[widg] = (titl, opt.get_name(),
"<b>%s</b>" % opt.get_name())
self.propagLabels[widg] = prop
table.show()
return table
def __init__(self, w3af, initial_request=None):
super(FuzzyRequests,
self).__init__(w3af, "fuzzyreq", "w3af - Fuzzy Requests",
"Fuzzy_Requests")
self.w3af = w3af
self.historyItem = HistoryItem()
mainhbox = gtk.HBox()
# To store the responses
self.responses = []
# ---- left pane ----
vbox = gtk.VBox()
mainhbox.pack_start(vbox, False, False)
# we create the buttons first, to pass them
analyzBut = gtk.Button("Analyze")
self.sendPlayBut = entries.SemiStockButton(
"", gtk.STOCK_MEDIA_PLAY, "Sends the pending requests")
self.sendStopBut = entries.SemiStockButton(
"", gtk.STOCK_MEDIA_STOP, "Stops the request being sent")
self.sSB_state = helpers.PropagateBuffer(
self.sendStopBut.set_sensitive)
self.sSB_state.change(self, False)
# Fix content length checkbox
self._fix_content_lengthCB = gtk.CheckButton(
'Fix content length header')
self._fix_content_lengthCB.set_active(True)
self._fix_content_lengthCB.show()
# request
self.originalReq = RequestPart(
self,
w3af, [
analyzBut.set_sensitive, self.sendPlayBut.set_sensitive,
functools.partial(self.sSB_state.change, 'rRV')
],
editable=True,
widgname='fuzzyrequest')
if initial_request is None:
self.originalReq.show_raw(FUZZY_REQUEST_EXAMPLE, '')
else:
(initialUp, initialDn) = initial_request
self.originalReq.show_raw(initialUp, initialDn)
# Add the right button popup menu to the text widgets
rawTextView = self.originalReq.get_view_by_id('HttpRawView')
rawTextView.textView.connect("populate-popup", self._populate_popup)
# help
helplabel = gtk.Label()
helplabel.set_selectable(True)
helplabel.set_markup(FUZZY_HELP)
self.originalReq.append_page(helplabel, gtk.Label("Syntax help"))
helplabel.show()
self.originalReq.show()
vbox.pack_start(self.originalReq, True, True, padding=5)
vbox.show()
# the commands
t = gtk.Table(2, 4)
analyzBut.connect("clicked", self._analyze)
t.attach(analyzBut, 0, 2, 0, 1)
self.analyzefb = gtk.Label("0 requests")
self.analyzefb.set_sensitive(False)
t.attach(self.analyzefb, 2, 3, 0, 1)
self.preview = gtk.CheckButton("Preview")
t.attach(self.preview, 3, 4, 0, 1)
self.sPB_signal = self.sendPlayBut.connect("clicked", self._send_start)
t.attach(self.sendPlayBut, 0, 1, 1, 2)
self.sendStopBut.connect("clicked", self._send_stop)
t.attach(self.sendStopBut, 1, 2, 1, 2)
self.sendfb = gtk.Label("0 ok, 0 errors")
self.sendfb.set_sensitive(False)
t.attach(self.sendfb, 2, 3, 1, 2)
t.attach(self._fix_content_lengthCB, 3, 4, 1, 2)
t.show_all()
vbox.pack_start(t, False, False, padding=5)
# ---- throbber pane ----
vbox = gtk.VBox()
self.throbber = helpers.Throbber()
self.throbber.set_sensitive(False)
vbox.pack_start(self.throbber, False, False)
vbox.show()
mainhbox.pack_start(vbox, False, False)
# ---- right pane ----
vbox = gtk.VBox()
mainhbox.pack_start(vbox)
# A label to show the id of the response
self.title0 = gtk.Label()
self.title0.show()
vbox.pack_start(self.title0, False, True)
# result itself
self.resultReqResp = ReqResViewer(w3af,
withFuzzy=False,
editableRequest=False,
editableResponse=False)
self.resultReqResp.set_sensitive(False)
vbox.pack_start(self.resultReqResp, True, True, padding=5)
vbox.show()
# result control
centerbox = gtk.HBox()
self.pagesControl = entries.PagesControl(w3af, self.page_change)
centerbox.pack_start(self.pagesControl, True, False)
centerbox.show()
# cluster responses button
image = gtk.Image()
image.set_from_file(
os.path.join(ROOT_PATH, 'core', 'ui', 'gui', 'data',
'cluster_data.png'))
image.show()
self.clusterButton = gtk.Button(label='Cluster responses')
self.clusterButton.connect("clicked", self._clusterData)
self.clusterButton.set_sensitive(False)
self.clusterButton.set_image(image)
self.clusterButton.show()
centerbox.pack_start(self.clusterButton, True, False)
# clear responses button
self.clearButton = entries.SemiStockButton(
'Clear Responses',
gtk.STOCK_CLEAR,
tooltip='Clear all HTTP responses from fuzzer window')
self.clearButton.connect("clicked", self._clearResponses)
self.clearButton.set_sensitive(False)
self.clearButton.show()
centerbox.pack_start(self.clearButton, True, False)
vbox.pack_start(centerbox, False, False, padding=5)
# Show all!
self._sendPaused = True
self.vbox.pack_start(mainhbox)
self.vbox.show()
mainhbox.show()
self.show()
def _button(self, text="", stock=None, tooltip=''):
"""Creates a button."""
b = entries.SemiStockButton(text, stock, tooltip)
b.show()
self.action_area.pack_start(b)
return b
def __init__(self, w3af, initial_request=None):
super(export_request,
self).__init__(w3af, "exportreq", "w3af - Export Requests",
"Export_Requests")
self.w3af = w3af
# different ways of exporting data
self._exporters = [('HTML', html_export), ('Ajax', ajax_export),
('Python', python_export), ('Ruby', ruby_export)]
# splitted panes
vpan = entries.RememberingVPaned(w3af, "pane-exportrequests")
# upper pane that shows HTTP request
vbox = gtk.VBox()
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.http_request = SimpleTextView()
sw.add(self.http_request)
vbox.pack_start(sw, True, True, padding=5)
# middle widgets that show the export method
table = gtk.Table(1, 6, homogeneous=True)
cb = gtk.combo_box_new_text()
for (lab, fnc) in self._exporters:
cb.append_text(lab)
b = gtk.Button(lab)
cb.set_active(0)
table.attach(cb, 2, 3, 0, 1)
b = entries.SemiStockButton("Export", gtk.STOCK_GO_DOWN,
_("Export the request"))
b.connect("clicked", self._export, cb)
table.attach(b, 3, 4, 0, 1)
vbox.pack_start(table, False, False, padding=5)
vpan.pack1(vbox)
# lower pane with exported data and save button
vbox = gtk.VBox()
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.exported_text = SimpleTextView()
sw.add(self.exported_text)
vbox.pack_start(sw, True, True, padding=5)
b = entries.SemiStockButton("Save request as...", gtk.STOCK_SAVE_AS,
_("Save request as..."))
b.connect("clicked", self._save_as)
vbox.pack_start(b, False, False, padding=5)
vpan.pack2(vbox)
# Show the data
if initial_request is None:
self.http_request.set_text(export_request_example)
else:
(request_header, request_body) = initial_request
self.http_request.set_text(request_header + '\n\n' + request_body)
func = self._exporters[0][1]
self.exported_text.set_text(func(self.http_request.get_text()))
self.vbox.pack_start(vpan, padding=10)
self.show_all()
def __init__(self, w3af, commHandler):
entries.RememberingWindow.__init__(self,
w3af,
"compare",
"w3af - Compare",
"Comparing_HTTP_traffic",
onDestroy=commHandler.destroy)
self.w3af = w3af
self.commHandler = commHandler
commHandler.enable(self, self.add_element)
# toolbar elements
uimanager = gtk.UIManager()
accelgroup = uimanager.get_accel_group()
self.add_accel_group(accelgroup)
actiongroup = gtk.ActionGroup('UIManager')
actiongroup.add_actions([
('Help', gtk.STOCK_HELP, '_Help', None,
'Help regarding this window', self._help),
('ClearAll', gtk.STOCK_CLEAR, '_Clear All', None,
'Clear all the texts', self._clearAll),
])
iconfactory = gtk.IconFactory()
iconfactory.add_default()
def make_iconset(path):
return gtk.IconSet(gtk.gdk.pixbuf_new_from_file(path))
iconfactory.add(
'req_head',
make_iconset(os.path.join(GUI_DATA_PATH, 'request-headers.png')))
iconfactory.add(
'req_body',
make_iconset(os.path.join(GUI_DATA_PATH, 'request-body.png')))
iconfactory.add(
'res_head',
make_iconset(os.path.join(GUI_DATA_PATH, 'response-headers.png')))
iconfactory.add(
'res_body',
make_iconset(os.path.join(GUI_DATA_PATH, 'response-body.png')))
gtk.stock_add(
(
('req_head', "Show Request Headers", 0,
gtk.gdk.keyval_from_name('1'), 'w3af'),
('req_body', "Show Request Body", 0,
gtk.gdk.keyval_from_name('2'), 'w3af'),
('res_head', "Show Response Headers", 0,
gtk.gdk.keyval_from_name('3'), 'w3af'),
('res_body', "Show Response Body", 0,
gtk.gdk.keyval_from_name('4'), 'w3af'),
))
actiongroup.add_toggle_actions([
# xml_name, icon, real_menu_text, accelerator, tooltip, callback, initial_flag
('ReqHeaders', 'req_head', '_Request Headers', None,
'Show/Hide the request headers', self._toggle_reqhead, False),
('ReqBody', 'req_body', '_Request Body', None,
'Show/Hide the request body', self._toggle_reqbody, False),
('RespHeaders', 'res_head', '_Response Headers', None,
'Show/Hide the response headers', self._toggle_resphead, True),
('RespBody', 'res_body', '_Response Body', None,
'Show/Hide the response body', self._toggle_respbody, True),
])
# finish the toolbar
uimanager.insert_action_group(actiongroup, 0)
uimanager.add_ui_from_string(ui_menu)
toolbar = uimanager.get_widget('/Toolbar')
assert toolbar.get_n_items() == 8
separat = toolbar.get_nth_item(6)
separat.set_draw(False)
separat.set_expand(True)
self.vbox.pack_start(toolbar, False)
self.tbarwidgets = [toolbar.get_nth_item(i) for i in range(6)]
# the line with the "send to" buttons
self.sendto_box = hbox = gtk.HBox()
b = entries.SemiStockButton(
"", gtk.STOCK_INDEX,
"Send the Request of the Left to Manual Editor")
b.connect("clicked", self._send_requests, "manual", "left")
hbox.pack_start(b, False, False, padding=2)
b = entries.SemiStockButton(
"", gtk.STOCK_PROPERTIES,
"Send the Request of the Left to Fuzzy Editor")
b.connect("clicked", self._send_requests, "fuzzy", "left")
hbox.pack_start(b, False, False, padding=2)
image = gtk.Image()
image.set_from_file(
os.path.join(
os.path.split(__file__)[0], 'data', 'cluster_data.png'))
image.show()
self.clusterbut = gtk.Button("")
self.clusterbut.set_tooltip_text("Send all to Cluster Responses")
self.clusterbut.set_image(image)
self.clusterbut.connect("clicked", self._sendCluster)
self.clusterbut.set_sensitive(False)
hbox.pack_end(self.clusterbut, False, False, padding=2)
b = entries.SemiStockButton(
"", gtk.STOCK_PROPERTIES,
"Send the Request of the Right to Fuzzy Editor")
b.connect("clicked", self._send_requests, "fuzzy", "right")
hbox.pack_end(b, False, False, padding=2)
b = entries.SemiStockButton(
"", gtk.STOCK_INDEX,
"Send the Request of the Right to Manual Editor")
b.connect("clicked", self._send_requests, "manual", "right")
hbox.pack_end(b, False, False, padding=2)
self.vbox.pack_start(hbox, False, False, padding=10)
# the comparator itself
self.comp = comparator.FileDiff()
self.vbox.pack_start(self.comp.widget)
# the page control
box = gtk.HBox()
self.pagesControl = entries.PagesControl(w3af, self._pageChange)
box.pack_start(self.pagesControl, False, False, padding=5)
self.delbut = gtk.Button("Delete")
self.delbut.connect("clicked", self._delete)
self.delbut.set_sensitive(False)
box.pack_start(self.delbut, False, False, padding=10)
self.comp.rightBaseBox.pack_start(box, True, False)
# the send to left button
box = gtk.HBox()
but = gtk.Button("Set text to compare")
but.set_tooltip_text(
"Sets the text of the right pane into the left one")
but.connect("clicked", self._rightToLeft)
box.pack_start(but, True, False)
self.comp.leftBaseBox.pack_start(box, True, False)
# this four bool list indicates which texts to show
self.showText = [False, False, True, True]
# other attributes
self.elements = []
self.showingPage = None
self.leftElement = None
self.sensitive_all(False)
self.show_all()
