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()