def init(self):
w, h, aa, threads = (512, 512, 1, 2)
canvas = RayTracePanel(w, h, aa, threads)
self.getContentPane().add(JScrollPane(canvas))
#Save FileChooser
#fcS = JFileChooser()
#fcS.addChoosableFileFilter(FileNameExtensionFilter('Windows Bitmap (*.bmp)', ['bmp']))
#fcS.addChoosableFileFilter(FileNameExtensionFilter('JPEG / JFIF (*.jpg)', ['jpg']))
#fcS.addChoosableFileFilter(FileNameExtensionFilter('Portable Network Graphics (*.png)', ['png']))
#def saveFile(event):
# '''Performed when the save button is pressed'''
# result = fcS.showSaveDialog(frame)
# if result == JFileChooser.APPROVE_OPTION:
# file = fcS.getSelectedFile()
# fname = file.getPath()
# ext = fcS.getFileFilter().getExtensions()[0]
# if not fname.endswith('.' + ext):
# file = File(fname + '.' + ext)
# canvas.saveToFile(file, ext)
#Open FileChooser
#fcO = JFileChooser()
#fcO.addChoosableFileFilter(FileNameExtensionFilter('RayTrace Scene File (*.rts)', ['rts']))
#def openFile(event):
# '''Performed when the open button is pressed'''
# result = fcO.showOpenDialog(frame)
# if result == JFileChooser.APPROVE_OPTION:
# fname = fcO.getSelectedFile().getPath()
# if fname.endswith('.rts'):
# f = open(fname, 'rb')
# newScene = SceneFactory().buildScene(f)
# f.close()
# Painter(canvas, newScene, openButton, saveButton, stopButton).start()
def stop(event):
'''Peformed when the stop button is pressed'''
canvas.stopRendering()
#Setup Menu
menuBar = JMenuBar()
menu = JMenu("File")
menuBar.add(menu)
#openButton = JMenuItem("Open...", actionPerformed=openFile)
#openButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK))
#menu.add(openButton)
#saveButton = JMenuItem("Save as...", actionPerformed=saveFile)
#saveButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK))
#menu.add(saveButton)
menu.addSeparator()
stopButton = JMenuItem('Stop Render', actionPerformed=stop)
stopButton.setAccelerator(KeyStroke.getKeyStroke(
KeyEvent.VK_ESCAPE, 0))
stopButton.setEnabled(False)
menu.add(stopButton)
menu.addSeparator()
#closeButton = JMenuItem('Close', actionPerformed=exit)
#closeButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK))
#menu.add(closeButton)
self.setJMenuBar(menuBar)
class ExecutorAction(ActionListener):
"""
ExecutorAction class represent a context-free action class container.
During creation an action should be passed to defined the behaviour of this context free action.
"""
def __init__(self, text, action=None):
self._action = action
self.menuitem = JMenuItem(text)
self.menuitem.setEnabled(True)
self.menuitem.addActionListener(self)
def actionPerformed(self, e):
"""
Executes action if setup during creation.
:param e: unused
:return: None
"""
if self._action:
self._action(e)
def ctx(self, host=None, payload=None, fname=None):
"""
Do Nothing, stub implemented to be an action.
This is not needed since the action to be performed is context free and setup during object creation.
:param host: unused
:param payload: unused
:param fname: unused
:return: None
"""
pass
def createMenuItems(self, invoker):
self.invoker = invoker
if not (invoker.getInvocationContext()
== IContextMenuInvocation.CONTEXT_MESSAGE_EDITOR_REQUEST
or invoker.getInvocationContext()
== IContextMenuInvocation.CONTEXT_MESSAGE_VIEWER_REQUEST
or invoker.getInvocationContext()
== IContextMenuInvocation.CONTEXT_TARGET_SITE_MAP_TABLE
or invoker.getInvocationContext()
== IContextMenuInvocation.CONTEXT_PROXY_HISTORY):
return None
self.messages = self.invoker.getSelectedMessages()
if self.messages is None:
return None
if len(self.messages) > 1:
button_text = "Send {} requests to CompuRacer".format(
len(self.messages))
else:
button_text = "Send request to CompuRacer"
global racer_alive
if not racer_alive:
button_text += " (offline)"
elif self.send_lock.locked():
button_text += " (busy)"
menu_send = JMenuItem(button_text,
actionPerformed=self.start_request_transmitter)
# self.set_icon(menu_send)
menu_send.setEnabled(racer_alive and not self.send_lock.locked())
return [menu_send]
def init(self):
w, h, aa, threads = (512, 512, 1, 2)
canvas = RayTracePanel(w, h, aa, threads)
self.getContentPane().add(JScrollPane(canvas))
# Save FileChooser
# fcS = JFileChooser()
# fcS.addChoosableFileFilter(FileNameExtensionFilter('Windows Bitmap (*.bmp)', ['bmp']))
# fcS.addChoosableFileFilter(FileNameExtensionFilter('JPEG / JFIF (*.jpg)', ['jpg']))
# fcS.addChoosableFileFilter(FileNameExtensionFilter('Portable Network Graphics (*.png)', ['png']))
# def saveFile(event):
# '''Performed when the save button is pressed'''
# result = fcS.showSaveDialog(frame)
# if result == JFileChooser.APPROVE_OPTION:
# file = fcS.getSelectedFile()
# fname = file.getPath()
# ext = fcS.getFileFilter().getExtensions()[0]
# if not fname.endswith('.' + ext):
# file = File(fname + '.' + ext)
# canvas.saveToFile(file, ext)
# Open FileChooser
# fcO = JFileChooser()
# fcO.addChoosableFileFilter(FileNameExtensionFilter('RayTrace Scene File (*.rts)', ['rts']))
# def openFile(event):
# '''Performed when the open button is pressed'''
# result = fcO.showOpenDialog(frame)
# if result == JFileChooser.APPROVE_OPTION:
# fname = fcO.getSelectedFile().getPath()
# if fname.endswith('.rts'):
# f = open(fname, 'rb')
# newScene = SceneFactory().buildScene(f)
# f.close()
# Painter(canvas, newScene, openButton, saveButton, stopButton).start()
def stop(event):
"""Peformed when the stop button is pressed"""
canvas.stopRendering()
# Setup Menu
menuBar = JMenuBar()
menu = JMenu("File")
menuBar.add(menu)
openButton = JMenuItem("Open...", actionPerformed=openFile)
openButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK))
menu.add(openButton)
# saveButton = JMenuItem("Save as...", actionPerformed=saveFile)
# saveButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK))
# menu.add(saveButton)
menu.addSeparator()
stopButton = JMenuItem("Stop Render", actionPerformed=stop)
stopButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0))
stopButton.setEnabled(False)
menu.add(stopButton)
menu.addSeparator()
# closeButton = JMenuItem('Close', actionPerformed=exit)
# closeButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK))
# menu.add(closeButton)
self.setJMenuBar(menuBar)
class SimpleMenuItem:
def __init__(self, text=None):
self.menuitem = JMenuItem(text)
self.menuitem.setEnabled(False)
def add_action_listener(self, action_listener):
self.menuitem.addActionListener(action_listener)
def set_enabled(self, enabled):
self.menuitem.setEnabled(enabled)
class SimpleMenuItem:
"""
An OmniMenuItem implemented on top of a single item entry.
"""
def __init__(self, text=None):
self.menuitem = JMenuItem(text)
self.menuitem.setEnabled(False)
def add_action_listener(self, action_listener):
self.menuitem.addActionListener(action_listener)
def set_enabled(self, enabled):
self.menuitem.setEnabled(enabled)
class OmniMenuItem(IContextMenuFactory):
"""Menu item for burp and inql interface. IT contains same action but it is shown in multiple places"""
def __init__(self, helpers=None, callbacks=None, text=''):
self._helpers = helpers
self._callbacks = callbacks
self.menuitem = JMenuItem(text)
self._burp_menuitem = JMenuItem("inql: %s" % text)
self.set_enabled(False)
self._callbacks.registerContextMenuFactory(self)
def add_action_listener(self, action_listener):
"""
add a new action listener to the given UI items.
"""
self._action_listener = action_listener
self.menuitem.addActionListener(action_listener)
self._burp_menuitem.addActionListener(action_listener)
def set_enabled(self, enabled):
"""
Enables or disables the menuitme
"""
self.menuitem.setEnabled(enabled)
self._burp_menuitem.setEnabled(enabled)
def createMenuItems(self, invocation):
"""
Overrides IContextMenuFactory callback
:param invocation: handles menu selected invocation
:return:
"""
try:
r = invocation.getSelectedMessages()[0]
info = self._helpers.analyzeRequest(r)
url = str(info.getUrl())
body = r.getRequest()[info.getBodyOffset():].tostring()
if not is_query(body):
return None
for h in info.getHeaders():
if h.lower().startswith("host:"):
domain = h[5:].strip()
self._action_listener.ctx(fname='dummy.query',
host=domain,
payload=body)
mymenu = []
mymenu.append(self._burp_menuitem)
except Exception as ex:
return None
return mymenu
class TestAction(ActionListener):
def __init__(self, text):
self.requests = {}
self.menuitem = JMenuItem(text)
self.menuitem.addActionListener(self)
self.enabled = True
self.menuitem.setEnabled(self.enabled)
def actionPerformed(self, e):
self.enabled = not self.enabled
self.menuitem.setEnabled(self.enabled)
def ctx(self, host=None, payload=None, fname=None):
pass
def createMenuItems(self, invoker):
self.invoker = invoker
self.selection = self.invoker.getSelectionBounds()
context = self.invoker.getInvocationContext()
if not (context == self.invoker.CONTEXT_MESSAGE_EDITOR_REQUEST or
context == self.invoker.CONTEXT_MESSAGE_VIEWER_REQUEST or
context == self.invoker.CONTEXT_MESSAGE_EDITOR_RESPONSE or
context == self.invoker.CONTEXT_MESSAGE_VIEWER_RESPONSE
):
return None
menu_translate_sel = JMenuItem(
self.src_menu_text, actionPerformed=self.translate)
menu_translate_sel.setEnabled(False)
menu_translate_clip = JMenuItem(
self.dst_menu_text, actionPerformed=self.translate)
menu_translate_clip.setEnabled(False)
if self.selection is not None and self.selection[0] != self.selection[1]:
menu_translate_sel.setEnabled(True)
if self.get_clipboard_text() is not None:
menu_translate_clip.setEnabled(True)
menu_header = JMenuItem('%s v%s' % (
BurpExtender.extension_name, BurpExtender.extension_version))
menu_header.setEnabled(False)
menu_src = JMenu(' - Source Language [%s]' % (self.src))
menu_dst = JMenu(' - Destination Language [%s]' % (self.dst))
menu_automatic = JCheckBoxMenuItem(
'Automatic', actionPerformed=self.select_src)
menu_src.add(menu_automatic)
if self.src == menu_automatic.getText():
menu_automatic.setSelected(True)
for lang in sorted(langs):
menu_item = JCheckBoxMenuItem(
lang, actionPerformed=self.select_src)
if lang == self.src:
menu_item.setSelected(True)
menu_src.add(menu_item)
menu_item = JCheckBoxMenuItem(
lang, actionPerformed=self.select_dst)
if lang == self.dst:
menu_item.setSelected(True)
menu_dst.add(menu_item)
return [menu_header, menu_src, menu_dst, menu_translate_sel, menu_translate_clip]
def createMenuItems(self, invoc):
menu = JMenuItem('Send WCF to Intruder')
menu.addMouseListener(CtxMenuMouseListener(self.extender, invoc))
enabled = True
for msg in invoc.getSelectedMessages():
headers = self.extender.helpers.analyzeRequest(
msg.getRequest()).getHeaders()
enabled = reduce(lambda acc, val: acc or is_wcf_header(val),
get_headers_containing('content-type', headers),
False)
if not enabled:
break
menu.setEnabled(enabled)
return [menu]
class OmniMenuItem(IContextMenuFactory):
def __init__(self, helpers=None, callbacks=None, text=''):
self._helpers = helpers
self._callbacks = callbacks
self.menuitem = JMenuItem(text)
self._burp_menuitem = JMenuItem("inql: %s" % text)
self.set_enabled(False)
self._callbacks.registerContextMenuFactory(self)
def add_action_listener(self, action_listener):
self._action_listener = action_listener
self.menuitem.addActionListener(action_listener)
self._burp_menuitem.addActionListener(action_listener)
def set_enabled(self, enabled):
self.menuitem.setEnabled(enabled)
self._burp_menuitem.setEnabled(enabled)
def createMenuItems(self, invocation):
"""
Overrides IContextMenuFactory callback
:param invocation: handles menu selected invocation
:return:
"""
try:
r = invocation.getSelectedMessages()[0]
info = self._helpers.analyzeRequest(r)
url = str(info.getUrl())
if not any([x in url for x in URLS]):
return None
body = r.getRequest()[info.getBodyOffset():].tostring()
for h in info.getHeaders():
if h.lower().startswith("host:"):
domain = h[5:].strip()
self._action_listener.ctx(fname='dummy.query',
host=domain,
payload=body)
mymenu = []
mymenu.append(self._burp_menuitem)
except Exception as ex:
return None
return mymenu
class BrowserAction(ActionListener):
"""
BrowserAction performs a new "Open In Browser" action when the context is set to an HTML File.
The idea is to show HTML documentation in a Browser, when generated and the context is correct
"""
def __init__(self, text="Open In Browser"):
self.menuitem = JMenuItem(text)
self.menuitem.setEnabled(False)
self.menuitem.addActionListener(self)
def actionPerformed(self, e):
"""
Override the ActionListener method. Usually setup in combination with a menuitem click.
:param e: unused
:return:
"""
URLOpener().open("file://%s" % self.target)
def ctx(self, host=None, payload=None, fname=None):
"""
Setup the current context
:param host: unused
:param payload: unused
:param fname: filename of the selected file
:return: None
"""
self.target = os.path.abspath(fname)
if self.target.endswith('.html'):
self.menuitem.setEnabled(True)
else:
self.menuitem.setEnabled(False)
def createMenuItems(self, invoker):
global immediate_data, compuracer_communication_lock
self.invoker = invoker
if not (invoker.getInvocationContext()
== IContextMenuInvocation.CONTEXT_MESSAGE_EDITOR_REQUEST
or invoker.getInvocationContext()
== IContextMenuInvocation.CONTEXT_MESSAGE_VIEWER_REQUEST
or invoker.getInvocationContext()
== IContextMenuInvocation.CONTEXT_TARGET_SITE_MAP_TABLE
or invoker.getInvocationContext()
== IContextMenuInvocation.CONTEXT_PROXY_HISTORY):
return None
self.messages = self.invoker.getSelectedMessages()
if self.messages is None:
return None
if len(self.messages) > 1:
button_text = "Send {} requests to CompuRacer".format(
len(self.messages))
else:
button_text = "Send request to CompuRacer"
global racer_alive
if not racer_alive:
button_text += " (offline)"
elif compuracer_communication_lock.locked():
button_text += " (busy)"
send_menu = JMenuItem(button_text,
actionPerformed=self.start_request_transmitter)
option_menu = JCheckBoxMenuItem("Immediate mode",
actionPerformed=self.mode_changed)
option_menu.setSelected(immediate_data['mode'] == 'on')
# self.set_icon(menu_send)
send_menu.setEnabled(racer_alive
and not compuracer_communication_lock.locked())
option_menu.setEnabled(racer_alive
and not compuracer_communication_lock.locked())
return [send_menu, option_menu]
class BrowserAction(ActionListener):
"""
BrowserAction performs a new "Open In Browser" action when the context is set to an HTML File.
The idea is to show HTML documentation in a Browser, when generated and the context is correct
"""
def __init__(self, text="Open In Browser"):
self.menuitem = JMenuItem(text)
self.menuitem.setEnabled(False)
self.menuitem.addActionListener(self)
self.openers = [
lambda url: Desktop.getDesktop().browse(URI(url)),
lambda url: subprocess.call(["xdg-open", url]),
lambda url: subprocess.call(["open", url])
]
def actionPerformed(self, e):
"""
Override the ActionListener method. Usually setup in combination with a menuitem click.
:param e: unused
:return:
"""
self._run(self.fname)
def ctx(self, host=None, payload=None, fname=None):
"""
Setup the current context
:param host: unused
:param payload: unused
:param fname: filename of the selected file
:return: None
"""
self.fname = os.path.abspath(fname)
if self.fname.endswith('.html'):
self.menuitem.setEnabled(True)
else:
self.menuitem.setEnabled(False)
def _run(self, url):
"""
Try to execute the first available browser. Since on every system (Darwin, Windows and Linux) this procedure is
different, iterate on every procedure and exit on the first successful one or on the last one altogether.
:param url: url to be opened
:return: None
"""
for opener in self.openers:
try:
opener(url)
return
except:
pass
class GraphIQLAction(ActionListener):
"""
BrowserAction performs a new "Open In Browser" action when the context is set to an HTML File.
The idea is to show HTML documentation in a Browser, when generated and the context is correct
"""
def __init__(self, text="Open in GraphIQL Console"):
self.menuitem = JMenuItem(text)
self.menuitem.setEnabled(False)
self.menuitem.addActionListener(self)
self.lookup = {}
def actionPerformed(self, e):
"""
Override the ActionListener method. Usually setup in combination with a menuitem click.
:param e: unused
:return:
"""
URLOpener().open(self.target)
def ctx(self, host=None, payload=None, fname=None):
"""
Setup the current context
:param host: unused
:param payload: unused
:param fname: filename of the selected file
:return: None
"""
protocols = ['http', 'https']
self.target = None
for protocol in protocols:
target = "%s://%s/graphiql" % (protocol, host)
if target in self.lookup and self.lookup[target] is False:
continue
try:
if target not in self.lookup:
os.environ['http_proxy'] = None
os.environ['https_proxy'] = None
urllib_request.urlopen(
urllib_request.Request(
target,
headers={
'User-Agent':
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.163 Safari/537.36'
}))
self.target = "%s://%s/graphiql" % (protocol, host)
self.lookup[target] = True
if os.path.abspath(fname).endswith('.query'):
self.target += "?query=%s" % urllib_request.quote(
json.loads(payload)['query'])
except Exception as ex:
self.lookup[target] = False
if self.target:
self.menuitem.setEnabled(True)
else:
self.menuitem.setEnabled(False)
class CustomHeaderSetterAction(ActionListener):
"""
Set Custom Header Action
"""
def __init__(self, overrideheaders, text="Set Custom Header"):
self.requests = {}
self.menuitem = JMenuItem(text)
self.menuitem.setEnabled(False)
self.menuitem.addActionListener(self)
self._overrideheaders = overrideheaders
self._host = None
def actionPerformed(self, e):
"""
Overrides ActionListener behaviour, when clicked it opens the headers property editor for the given host.
:param e: unused
:return:
"""
if self._host:
try:
self._overrideheaders[self._host]
except KeyError:
print("No custom header for %s, generating an empty set" %
self._host)
self._overrideheaders[self._host] = []
PropertyEditor.get_instance(
"Set Custom Header for %s" % self._host,
columns=["Header", "Value"],
data=self._overrideheaders[self._host],
empty=["X-New-Header", "X-New-Header-Value"])
def ctx(self, host=None, payload=None, fname=None):
"""
implements the context setting behaviour
:param host: when host is not null set it and enable the menuitem.
:param payload: ignored
:param fname: ignored
:return:
"""
if host:
self.menuitem.setEnabled(True)
else:
self.menuitem.setEnabled(False)
self._host = host
def run(scene, w=512, h=512, aa=1, threads=1):
'''Create GUI and perform ray-tracing.'''
#Make Swing not look like garbage (so much)
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName())
#Setup frame
frame = JFrame("RayTracer",
defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
size=(w, h))
frame.setIconImage(ImageIcon('resources/icon.png').getImage())
canvas = RayTracePanel(w, h, aa, threads)
frame.getContentPane().add(JScrollPane(canvas))
#Save FileChooser
fcS = JFileChooser()
fcS.addChoosableFileFilter(
FileNameExtensionFilter('Windows Bitmap (*.bmp)', ['bmp']))
fcS.addChoosableFileFilter(
FileNameExtensionFilter('JPEG / JFIF (*.jpg)', ['jpg']))
fcS.addChoosableFileFilter(
FileNameExtensionFilter('Portable Network Graphics (*.png)', ['png']))
def saveFile(event):
'''Performed when the save button is pressed'''
result = fcS.showSaveDialog(frame)
if result == JFileChooser.APPROVE_OPTION:
file = fcS.getSelectedFile()
fname = file.getPath()
ext = fcS.getFileFilter().getExtensions()[0]
if not fname.endswith('.' + ext):
file = File(fname + '.' + ext)
canvas.saveToFile(file, ext)
#Open FileChooser
fcO = JFileChooser()
fcO.addChoosableFileFilter(
FileNameExtensionFilter('RayTrace Scene File (*.rts)', ['rts']))
def openFile(event):
'''Performed when the open button is pressed'''
result = fcO.showOpenDialog(frame)
if result == JFileChooser.APPROVE_OPTION:
fname = fcO.getSelectedFile().getPath()
if fname.endswith('.rts'):
f = open(fname, 'rb')
newScene = SceneFactory().buildScene(f)
f.close()
Painter(canvas, newScene, openButton, saveButton,
stopButton).start()
def exit(event):
'''Performed when the exit button is pressed'''
import sys
sys.exit(0)
def stop(event):
'''Peformed when the stop button is pressed'''
canvas.stopRendering()
#Setup Menu
menuBar = JMenuBar()
menu = JMenu("File")
menuBar.add(menu)
openButton = JMenuItem("Open...", actionPerformed=openFile)
openButton.setAccelerator(
KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK))
menu.add(openButton)
saveButton = JMenuItem("Save as...", actionPerformed=saveFile)
saveButton.setAccelerator(
KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK))
menu.add(saveButton)
menu.addSeparator()
stopButton = JMenuItem('Stop Render', actionPerformed=stop)
stopButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0))
stopButton.setEnabled(False)
menu.add(stopButton)
menu.addSeparator()
closeButton = JMenuItem('Close', actionPerformed=exit)
closeButton.setAccelerator(
KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK))
menu.add(closeButton)
frame.setJMenuBar(menuBar)
#Finish initializing GUI
self.pack()
class RepeaterSenderAction(IProxyListener, ActionListener,
IContextMenuFactory):
def __init__(self, callbacks, helpers, text, overrideheaders):
self.requests = {}
self._helpers = helpers
self._callbacks = callbacks
self.menuitem = JMenuItem(text)
self._burp_menuitem = JMenuItem("inql: %s" % text)
self._callbacks.registerProxyListener(self)
self.menuitem.addActionListener(self)
self.menuitem.setEnabled(False)
self._burp_menuitem.addActionListener(self)
self._burp_menuitem.setEnabled(False)
self._index = 0
self._host = None
self._payload = None
self._fname = None
for r in self._callbacks.getProxyHistory():
self._process_request(self._helpers.analyzeRequest(r),
r.getRequest())
self._callbacks.registerContextMenuFactory(self)
self._overrideheaders = overrideheaders
def processProxyMessage(self, messageIsRequest, message):
"""
Implements IProxyListener method
:param messageIsRequest: True if BURP Message is a request
:param message: message content
:return: None
"""
if messageIsRequest:
self._process_request(
self._helpers.analyzeRequest(message.getMessageInfo()),
message.getMessageInfo().getRequest())
def _process_request(self, reqinfo, reqbody):
"""
Process request and extract key values
:param reqinfo:
:param reqbody:
:return:
"""
url = str(reqinfo.getUrl())
if any([url.endswith(x) for x in URLS]):
for h in reqinfo.getHeaders():
if h.lower().startswith("host:"):
domain = h[5:].strip()
method = reqinfo.getMethod()
try:
self.requests[domain]
except KeyError:
self.requests[domain] = {
'POST': None,
'PUT': None,
'GET': None
}
self.requests[domain][method] = (reqinfo, reqbody)
def actionPerformed(self, e):
"""
Overrides ActionListener behaviour. Send current query to repeater.
:param e: unused
:return: None
"""
req = self.requests[self._host]['POST'] or self.requests[
self._host]['PUT'] or self.requests[self._host]['GET']
if req:
info = req[0]
body = req[1]
nobody = body[:info.getBodyOffset()].tostring()
rstripoffset = info.getBodyOffset() - len(nobody.rstrip())
headers = body[:info.getBodyOffset() - rstripoffset].tostring()
try:
self._overrideheaders[self._host]
except KeyError:
self._overrideheaders[self._host] = []
repeater_body = StringUtil.toBytes(
string_join(
override_headers(headers,
self._overrideheaders[self._host]),
body[info.getBodyOffset() -
rstripoffset:info.getBodyOffset()].tostring(),
self._payload))
self._callbacks.sendToRepeater(
info.getUrl().getHost(),
info.getUrl().getPort(),
info.getUrl().getProtocol() == 'https', repeater_body,
'GraphQL #%s' % self._index)
self._index += 1
def ctx(self, host=None, payload=None, fname=None):
"""
When a fname is specified and is a query file or a request is selected in the other tabs,
enables the context menu to send to repeater tab
:param host: should be not null
:param payload: should be not null
:param fname: should be not null
:return: None
"""
self._host = host
self._payload = payload
self._fname = fname
if not self._fname.endswith('.query'):
self.menuitem.setEnabled(False)
self._burp_menuitem.setEnabled(False)
return
try:
self.requests[host]
self.menuitem.setEnabled(True)
self._burp_menuitem.setEnabled(True)
except KeyError:
self.menuitem.setEnabled(False)
self._burp_menuitem.setEnabled(False)
def createMenuItems(self, invocation):
"""
Overrides IContextMenuFactory callback
:param invocation: handles menu selected invocation
:return:
"""
try:
r = invocation.getSelectedMessages()[0]
info = self._helpers.analyzeRequest(r)
url = str(info.getUrl())
if not any([x in url for x in URLS]):
return None
body = r.getRequest()[info.getBodyOffset():].tostring()
for h in info.getHeaders():
if h.lower().startswith("host:"):
domain = h[5:].strip()
self.ctx(fname='dummy.query', host=domain, payload=body)
mymenu = []
mymenu.append(self._burp_menuitem)
except Exception as ex:
return None
return mymenu
def run(scene, w=512, h=512, aa=1, threads=1):
"""Create GUI and perform ray-tracing."""
# Make Swing not look like garbage (so much)
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName())
# Setup frame
frame = JFrame("RayTracer", defaultCloseOperation=JFrame.EXIT_ON_CLOSE, size=(w, h))
frame.setIconImage(ImageIcon("resources/icon.png").getImage())
canvas = RayTracePanel(w, h, aa, threads)
frame.getContentPane().add(JScrollPane(canvas))
# Save FileChooser
fcS = JFileChooser()
fcS.addChoosableFileFilter(FileNameExtensionFilter("Windows Bitmap (*.bmp)", ["bmp"]))
fcS.addChoosableFileFilter(FileNameExtensionFilter("JPEG / JFIF (*.jpg)", ["jpg"]))
fcS.addChoosableFileFilter(FileNameExtensionFilter("Portable Network Graphics (*.png)", ["png"]))
def saveFile(event):
"""Performed when the save button is pressed"""
result = fcS.showSaveDialog(frame)
if result == JFileChooser.APPROVE_OPTION:
file = fcS.getSelectedFile()
fname = file.getPath()
ext = fcS.getFileFilter().getExtensions()[0]
if not fname.endswith("." + ext):
file = File(fname + "." + ext)
canvas.saveToFile(file, ext)
# Open FileChooser
fcO = JFileChooser()
fcO.addChoosableFileFilter(FileNameExtensionFilter("RayTrace Scene File (*.rts)", ["rts"]))
def openFile(event):
"""Performed when the open button is pressed"""
result = fcO.showOpenDialog(frame)
if result == JFileChooser.APPROVE_OPTION:
fname = fcO.getSelectedFile().getPath()
if fname.endswith(".rts"):
f = open(fname, "rb")
newScene = SceneFactory().buildScene(f)
f.close()
Painter(canvas, newScene, openButton, saveButton, stopButton).start()
def exit(event):
"""Performed when the exit button is pressed"""
import sys
sys.exit(0)
def stop(event):
"""Peformed when the stop button is pressed"""
canvas.stopRendering()
# Setup Menu
menuBar = JMenuBar()
menu = JMenu("File")
menuBar.add(menu)
openButton = JMenuItem("Open...", actionPerformed=openFile)
openButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK))
menu.add(openButton)
saveButton = JMenuItem("Save as...", actionPerformed=saveFile)
saveButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK))
menu.add(saveButton)
menu.addSeparator()
stopButton = JMenuItem("Stop Render", actionPerformed=stop)
stopButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0))
stopButton.setEnabled(False)
menu.add(stopButton)
menu.addSeparator()
closeButton = JMenuItem("Close", actionPerformed=exit)
closeButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK))
menu.add(closeButton)
frame.setJMenuBar(menuBar)
# Finish initializing GUI
self.pack()
class HRRGraph(graph.Graph):
def __init__(self, view, name, func, args=(), filter=True, ylimits=(-1.0, 1.0), label=None, nodeid=None):
self.fixed_value = None
self.cache = {}
self.cache_dt_tau = None
self.cache_tick_count = 0
graph.Graph.__init__(self, view, name, func, args=args, filter=filter, ylimits=ylimits, split=False, neuronmapped=False, label=label)
self.border_top = 30
self.vocab = hrr.Vocabulary.registered.get(nodeid, None)
if self.vocab is None:
dim = len(self.data.get_first())
if dim in hrr.Vocabulary.defaults.keys():
self.vocab = hrr.Vocabulary.defaults[dim]
else:
self.vocab = hrr.Vocabulary(dim)
self.hidden_pairs = None
self.normalize = True
self.popup_normalize = JCheckBoxMenuItem('normalize', self.normalize, stateChanged=self.toggle_normalize)
self.popup.add(self.popup_normalize)
self.smooth_normalize = False
self.popup_smooth = JCheckBoxMenuItem('smooth normalize', self.smooth_normalize, stateChanged=self.toggle_smooth_normalize)
self.smooth_normalize_threshold = 0.4
self.popup.add(self.popup_smooth)
self.show_pairs = False
self.popup_pairs = JCheckBoxMenuItem('show pairs', self.show_pairs, stateChanged=self.toggle_show_pairs)
self.popup.add(self.popup_pairs)
self.show_graph = True
self.popup_graph = JCheckBoxMenuItem('show graph', self.show_graph, stateChanged=self.toggle_show_graph)
self.popup.add(self.popup_graph)
self.font_height_50 = None
self.popup_set = JMenuItem('set value', actionPerformed=self.set_value)
self.popup.add(self.popup_set)
self.popup_release = JMenuItem('release value', actionPerformed=self.release_value)
self.popup_release.setEnabled(False)
self.popup.add(self.popup_release)
def toggle_normalize(self, event):
if event.source.state == self.normalize:
return
self.normalize = event.source.state
if self.normalize and self.smooth_normalize:
self.popup_smooth.state = False
self.clear_cache()
self.repaint()
def toggle_smooth_normalize(self, event):
if event.source.state == self.smooth_normalize:
return
self.smooth_normalize = event.source.state
if self.smooth_normalize and self.normalize:
self.popup_normalize.state = False
self.clear_cache()
self.repaint()
def toggle_show_pairs(self, event):
if event.source.state == self.show_pairs:
return
self.show_pairs = event.source.state
self.redo_indices()
def toggle_show_graph(self, event):
self.show_graph = event.source.state
def redo_indices(self):
if self.indices is None:
return
self.clear_cache()
if self.show_pairs:
if self.vocab.vector_pairs is None:
self.vocab.generate_pairs()
pairs = self.indices[len(self.vocab.keys):]
if self.hidden_pairs is not None:
pairs.extend(self.hidden_pairs)
pairs = pairs + [False] * (len(self.vocab.key_pairs) - len(pairs))
self.indices = self.indices[:len(self.vocab.keys)]
if len(self.indices) < len(self.vocab.keys):
self.indices.extend([True] * (len(self.vocab.keys) - len(self.indices)))
if self.show_pairs:
self.indices = self.indices + pairs
self.hidden_pairs = None
else:
self.hidden_pairs = pairs
self.refix_popup()
self.repaint()
def save(self):
info = graph.Graph.save(self)
info['show_pairs'] = self.show_pairs
info['normalize'] = self.normalize
info['smooth_normalize'] = self.smooth_normalize
info['show_graph'] = self.show_graph
return info
def restore(self, d):
self.show_pairs = d.get('show_pairs', self.vocab.include_pairs)
self.popup_pairs.state = self.show_pairs
self.normalize = d.get('normalize', False)
self.popup_normalize.state = self.normalize
self.smooth_normalize = d.get('smooth_normalize', True)
self.popup_smooth.state = self.smooth_normalize
self.show_graph = d.get('show_graph', True)
self.popup_graph.state = self.show_graph
graph.Graph.restore(self, d)
def label_for_index(self, index):
if index < len(self.vocab.keys):
text = self.vocab.keys[index]
else:
text = self.vocab.key_pairs[index - len(self.vocab.keys)]
return text
def set_value(self, event):
key_count = len(self.vocab.keys)
try:
text = JOptionPane.showInputDialog(self.view.frame, 'Enter the symbolic value to represent.\nFor example: "a*b+0.3*(c*d+e)*~f"', "Set semantic pointer", JOptionPane.PLAIN_MESSAGE, None, None, None)
v = self.vocab.parse(text)
except:
self.release_value(event)
return
if isinstance(v, (int, float)):
v = [v] * self.vocab.dimensions
else:
v = v.v
self.fixed_value = v
self.popup_release.setEnabled(True)
self.view.forced_origins[(self.name, 'X', None)] = self.fixed_value
if key_count != len(self.vocab.keys):
self.view.refresh_hrrs()
def release_value(self, event):
self.fixed_value = None
self.popup_release.setEnabled(False)
key = (self.name, 'X', None)
if key in self.view.forced_origins:
del self.view.forced_origins[key]
def paintComponent(self, g):
if self.show_graph:
graph.Graph.paintComponent(self, g)
else:
core.DataViewComponent.paintComponent(self, g)
dt_tau = None
if self.filter and self.view.tau_filter > 0:
dt_tau = self.view.dt / self.view.tau_filter
try:
data = self.data.get(start=self.view.current_tick, count=1, dt_tau=dt_tau)[0]
except:
return
if data is None:
return
if self.normalize or self.smooth_normalize:
data = self.calc_normal(data)
if self.show_graph:
text = self.vocab.text(data, threshold=0.3, join=',', include_pairs=self.show_pairs)
g.color = Color.black
bounds = g.font.getStringBounds(text, g.fontRenderContext)
g.drawString(text, self.size.width / 2 - bounds.width / 2, 25 + self.label_offset)
else:
if self.font_height_50 is None:
self.font_height_50 = self.getFontMetrics(Font('SansSerif', Font.BOLD, 50)).getHeight()
items = []
total = 0
for i, dp in enumerate(self.vocab.dot(data)):
if dp > 0.1:
items.append((self.vocab.keys[i], dp))
total += dp
if self.show_pairs:
d = self.vocab.dot_pairs(data)
if d is not None:
for i, dp in enumerate(d):
if dp > 0.1:
items.append((self.vocab.key_pairs[i], dp))
total += dp
if total > 0:
scale = (self.size.height - self.label_offset - 25) / total
y = self.label_offset
for name, dp in items:
g.color = Color(0.0, 0.0, 0.0, min(dp, 1.0))
font_size = int(dp * scale * 50 / self.font_height_50)
g.font = Font('SansSerif', Font.BOLD, font_size)
bounds = g.font.getStringBounds(name, g.fontRenderContext)
g.drawString(name, self.size.width / 2 - bounds.width / 2, y + bounds.height)
y += bounds.height
def calc_normal(self, v):
length = 0
for i in range(len(v)):
length += v[i] * v[i]
length = math.sqrt(length)
if length > 0:
scale = 1.0 / length
else:
scale = 0
if self.smooth_normalize and length < self.smooth_normalize_threshold:
scale = 1.0 / self.smooth_normalize_threshold
v = [x * scale for x in v]
return v
def clear_cache(self):
self.cache.clear()
self.cache_tick_count = 0
def post_process(self, data, start, dt_tau):
if dt_tau != self.cache_dt_tau or self.cache_tick_count > self.view.watcher.timelog.tick_count:
self.cache_dt_tau = dt_tau
self.clear_cache()
self.cache_tick_count = self.view.watcher.timelog.tick_count
forget = self.cache_tick_count - self.view.watcher.timelog.tick_limit
if forget in self.cache:
del self.cache[forget]
if not hasattr(self, 'vocab'):
return []
if len(self.vocab.keys) == 0:
return []
d = []
for i, dd in enumerate(data):
if dd is None:
d.append(None)
else:
index = i + start
v = self.cache.get((index, dt_tau), None)
if v is None:
if self.normalize or self.smooth_normalize:
dd = self.calc_normal(dd)
v = self.vocab.dot(dd)
if self.show_pairs:
v2 = self.vocab.dot_pairs(dd)
if v2 is not None:
v = numeric.concatenate((v, v2), 0)
self.cache[(index, dt_tau)] = v
d.append(v)
return d
class Window (object): def __init__(self, windowManager, commandConsoleFactory, subject, windowTitle): self._windowManager = windowManager self.onCloseRequestListener = None # EDIT MENU transferActionListener = _TransferActionListener() editMenu = JMenu( 'Edit' ) if Platform.getPlatform() is Platform.MAC: command_key_mask = ActionEvent.META_MASK else: command_key_mask = ActionEvent.CTRL_MASK; self.__editUndoItem = JMenuItem( 'Undo' ) undoAction = _action( 'undo', self.__onUndo ) self.__editUndoItem.setActionCommand( undoAction.getValue( Action.NAME ) ) self.__editUndoItem.addActionListener( undoAction ) self.__editUndoItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Z, command_key_mask ) ) self.__editUndoItem.setMnemonic( KeyEvent.VK_U ) editMenu.add( self.__editUndoItem ) self.__editRedoItem = JMenuItem( 'Redo' ) redoAction = _action( 'redo', self.__onRedo ) self.__editRedoItem.setActionCommand( redoAction.getValue( Action.NAME ) ) self.__editRedoItem.addActionListener( redoAction ) self.__editRedoItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Y, command_key_mask ) ) self.__editRedoItem.setMnemonic( KeyEvent.VK_R ) editMenu.add( self.__editRedoItem ) editMenu.addSeparator() editCutItem = JMenuItem( 'Cut' ) editCutItem.setActionCommand( TransferHandler.getCutAction().getValue( Action.NAME ) ) editCutItem.addActionListener( transferActionListener ) editCutItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_X, command_key_mask ) ) editCutItem.setMnemonic( KeyEvent.VK_T ) editMenu.add( editCutItem ) editCopyItem = JMenuItem( 'Copy' ) editCopyItem.setActionCommand( TransferHandler.getCopyAction().getValue( Action.NAME ) ) editCopyItem.addActionListener( transferActionListener ) editCopyItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_C, command_key_mask ) ) editCopyItem.setMnemonic( KeyEvent.VK_C ) editMenu.add( editCopyItem ) editPasteItem = JMenuItem( 'Paste' ) editPasteItem.setActionCommand( TransferHandler.getPasteAction().getValue( Action.NAME ) ) editPasteItem.addActionListener( transferActionListener ) editPasteItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_V, command_key_mask ) ) editPasteItem.setMnemonic( KeyEvent.VK_P ) editMenu.add( editPasteItem ) editMenu.addSeparator() self.__showUndoHistoryItem = JMenuItem( 'Show undo history' ) self.__showUndoHistoryItem.addActionListener( _action( 'Show undo history', self.__onShowUndoHistory ) ) editMenu.add( self.__showUndoHistoryItem ) # HELP MENU helpMenu = JMenu( 'Help' ) helpToggleTooltipHighlightsItem = JMenuItem( 'Toggle tooltip highlights' ) toggleTooltipHighlightsAction = _action( 'Toggle tooltip highlights', self.__onToggleTooltipHighlights ) helpToggleTooltipHighlightsItem.setActionCommand( toggleTooltipHighlightsAction.getValue( Action.NAME ) ) helpToggleTooltipHighlightsItem.addActionListener( toggleTooltipHighlightsAction ) helpToggleTooltipHighlightsItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_F2, 0 ) ) helpMenu.add( helpToggleTooltipHighlightsItem ) helpMenu.add( _action( 'Show all tip boxes', self.__onShowAllTipBoxes ) ) # MENU BAR menuBar = JMenuBar() menuBar.add( editMenu ) menuBar.add( helpMenu ) # BROWSER # Initialise here, as the browser listener may invoke methods upon the browser's creation class _BrowserListener (TabbedBrowser.TabbedBrowserListener): def createNewBrowserWindow(_self, subject): self._onOpenNewWindow( subject ) def onTabbledBrowserChangePage(_self, browser): pass def inspectFragment(fragment, sourceElement, triggeringEvent): return self._windowManager.world.inspectFragment( fragment, sourceElement, triggeringEvent ) def onChangeHistoryChanged(history): self.__refreshChangeHistoryControls( history ) self._browser = TabbedBrowser( self._windowManager.world.rootSubject, subject, inspectFragment, _BrowserListener(), commandConsoleFactory ) self._browser.getComponent().setPreferredSize( Dimension( 800, 600 ) ) changeHistory = self._browser.getChangeHistory() self._browser.getChangeHistory().addChangeHistoryListener(onChangeHistoryChanged) # MAIN PANEL windowPanel = JPanel() windowPanel.setLayout( BoxLayout( windowPanel, BoxLayout.Y_AXIS ) ) windowPanel.add( self._browser.getComponent() ) # WINDOW class _WindowLister (WindowListener): def windowActivated(listenerSelf, event): pass def windowClosed(listenerSelf, event): pass def windowClosing(listenerSelf, event): if self.onCloseRequestListener is not None: self.onCloseRequestListener( self ) def windowDeactivated(listenerSelf, event): pass def windowDeiconified(listenerSelf, event): pass def windowIconified(listenerSelf, event): pass def windowOpened(listenerSelf, event): pass self.__frame = JFrame( windowTitle ) self.__frame.setJMenuBar( menuBar ) self.__frame.add( windowPanel ) self.__frame.addWindowListener( _WindowLister() ) self.__frame.setDefaultCloseOperation( JFrame.DO_NOTHING_ON_CLOSE ) self.__frame.pack() # Cause command history controls to refresh self.__refreshChangeHistoryControls( None ) @property def frame(self): return self.__frame @property def tabbedBrowser(self): return self._browser @property def currentBrowser(self): return self._browser.getCurrentBrowser() def show(self): self.__frame.setVisible( True ) def close(self): self.__frame.dispose() def __refreshChangeHistoryControls(self, changeHistory): if changeHistory is not None: self.__editUndoItem.setEnabled( changeHistory.canUndo() ) self.__editRedoItem.setEnabled( changeHistory.canRedo() ) self.__showUndoHistoryItem.setEnabled( True ) else: self.__editUndoItem.setEnabled( False ) self.__editRedoItem.setEnabled( False ) self.__showUndoHistoryItem.setEnabled( False ) def _onOpenNewWindow(self, subject): self._windowManager._createNewWindow( subject ) def __onUndo(self): changeHistory = self._browser.getChangeHistory() if changeHistory.canUndo(): changeHistory.concreteChangeHistory().undo() def __onRedo(self): changeHistory = self._browser.getChangeHistory() if changeHistory.canRedo(): changeHistory.concreteChangeHistory().redo() def __onShowUndoHistory(self): changeHistory = self._browser.getChangeHistory().concreteChangeHistory() if changeHistory is not None: subject = DefaultPerspective.instance.objectSubject( changeHistory ) self._browser.openSubjectInNewWindow( subject ) def __onToggleTooltipHighlights(self): AttachTooltip.toggleHighlights() def __onShowAllTipBoxes(self): TipBox.resetTipHiddenStates()
