class positionDialog(JFrame): def __init__(self): self.frame = JFrame("CellCropper: Experiment details", size=(400,200)) self.frame.setLocation(20,120) self.Panel = JPanel(GridLayout(4,2)) self.frame.add(self.Panel) self.Panel.add(JLabel("Date:")) self.dateField = JTextField( str(date.today()), 8 ) self.Panel.add(self.dateField) self.strainField = JTextField( "2926",4 ) self.Panel.add(self.strainField) self.tempField = JTextField( "34",2 ) self.Panel.add(self.tempField) self.ODField = JTextField( "0.5",3 ) self.Panel.add(self.ODField) self.condField = JTextField( "0.5",3 ) self.Panel.add(self.condField) self.OKButton = JButton("OK",actionPerformed=closeAndMakePos) self.Panel.add(self.OKButton) self.frame.pack() WindowManager.addWindow(self.frame) self.show() def show(self): self.frame.visible = True def close(self): return self.dateField.text, self.strainField.text, self.tempField.text, self.ODField.text, self.condField.text WindowManager.removeWindow(self.frame) self.frame.dispose()
class _AccountAdder: def __init__(self, contactslist): self.contactslist = contactslist self.mainframe = JFrame("Add New Contact") self.account = JComboBox(self.contactslist.clientsByName.keys()) self.contactname = JTextField() self.buildpane() def buildpane(self): buttons = JPanel() buttons.add(JButton("OK", actionPerformed=self.add)) buttons.add(JButton("Cancel", actionPerformed=self.cancel)) acct = JPanel(GridLayout(1, 2), doublebuffered) acct.add(JLabel("Account")) acct.add(self.account) mainpane = self.mainframe.getContentPane() mainpane.setLayout(BoxLayout(mainpane, BoxLayout.Y_AXIS)) mainpane.add(self.contactname) mainpane.add(acct) mainpane.add(buttons) self.mainframe.pack() self.mainframe.show() #action listeners def add(self, ae): acct = self.contactslist.clientsByName[self.account.getSelectedItem()] acct.addContact(self.contactname.getText()) self.mainframe.dispose() def cancel(self, ae): self.mainframe.dispose()
class View(JComponent): def __init__(self, obj, location, size=(800, 600), keys=None): JComponent.__init__(self) self.location = list(location) self.buffer = FrameBuffer( size[0], size[1], FrameBuffer.SAMPLINGMODE_NORMAL) self.obj = obj self.frame = JFrame(keyPressed=self.keyPressed, keyReleased=self.keyReleased) self.frame.add(self) self.size = size self.frame.pack() self.frame.size = size self.frame.visible = True self.clearColor = Color(0x666666) self.keys = keys def paint(self, g): x, y, z = self.location self.obj.world.camera.setPosition(x, -y, z) self.obj.world.camera.lookAt(SimpleVector(0, 0, 0)) self.buffer.clear(self.clearColor) self.obj.world.renderScene(self.buffer) self.obj.world.draw(self.buffer) self.buffer.update() self.buffer.display(g) self.repaint() def keyReleased(self, event): if self.keys is not None and hasattr(self.keys, 'key_released'): self.keys.key_released(KeyEvent.getKeyText(event.keyCode)) def keyPressed(self, event): if self.keys is not None and hasattr(self.keys, 'key_pressed'): self.keys.key_pressed(KeyEvent.getKeyText(event.keyCode)) if event.keyCode == KeyEvent.VK_ESCAPE: self.frame.dispose() elif event.keyCode == KeyEvent.VK_PAGE_UP: self.obj.sch.rate *= 1.1 self.frame.title = 'rate: %1.3f' % self.obj.sch.rate elif event.keyCode == KeyEvent.VK_PAGE_DOWN: self.obj.sch.rate /= 1.1 self.frame.title = 'rate: %1.3f' % self.obj.sch.rate elif event.keyCode == KeyEvent.VK_Z: self.location[2] += 1 elif event.keyCode == KeyEvent.VK_X: self.location[2] -= 1 elif event.keyCode == KeyEvent.VK_W: self.location[1] += 1 elif event.keyCode == KeyEvent.VK_S: self.location[1] -= 1 elif event.keyCode == KeyEvent.VK_A: self.location[0] += 1 elif event.keyCode == KeyEvent.VK_D: self.location[0] -= 1
def run_update(self): #from javax.swing import JFrame, JButton frame = JFrame("Hello") frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) frame.setLocation(100, 100) frame.setSize(300, 200) def updatePressed(event): jmri.jmrit.signalling.SignallingPanel.updatePressed(ActionEvent)(e) btn = JButton("Add", actionPerformed=updatePressed) frame.add(btn) frame.setVisible(True) btn.doClick frame.dispose()
def cachedBPROM(genome, fileName, frame): """ genome: Genome as a string. fileName: File to save the BPROM results in. swing: A JFrame or None. If this is None then messages will be printed, if it isn't then they will also be put in a dialog box. return: Results of the BPROM prediction stored in a list of Promoter objects. If the file Specified by fileName already exists then this function simply parses the file already there. Also, if a request is made to BPROM and nothing is returned, no file is created, the user is warned, and an empty list is returned. """ offset = 25 if ".forward.bprom" in fileName else 50 direction = "forward" if offset == 50 else "reverse" def getPromoters(): input = open(fileName, "r") results = parseBPROM(input.read()) input.close() return results if not os.path.isfile(fileName): results = urllib.urlopen("http://linux1.softberry.com/cgi-bin/programs/gfindb/bprom.pl", urllib.urlencode({"DATA" : genome})) resultString = results.read() results.close() resultString = resultString[resultString.find("<pre>"):resultString.find("</pre>")] resultString = re.sub("<+.+>+", "", resultString).strip() if resultString: output = open(fileName, "w") output.write(resultString) output.close() return getPromoters() else: if frame: messageFrame = JFrame("BPROM Error", defaultCloseOperation = WindowConstants.DISPOSE_ON_CLOSE) messageFrame.setLocation(frame.location().x + offset, frame.location().y + offset) messageFrame.contentPane.layout = GridBagLayout() constraints = GridBagConstraints() constraints.gridx, constraints.gridy = 0, 0 constraints.gridwidth, constraints.gridheight = 1, 1 constraints.fill = GridBagConstraints.BOTH constraints.weightx, constraints.weighty = 1, 1 messageFrame.contentPane.add(JLabel("<html>The pipeline will continue to run but BPROM<br/>did not process the request for promoters on the<br/>" + direction + " strand. Try again tomorrow.</html>"), constraints) constraints.gridx, constraints.gridy = 0, 1 constraints.fill = GridBagConstraints.NONE constraints.weightx, constraints.weighty = 1, 1 constraints.anchor = GridBagConstraints.LINE_END messageFrame.contentPane.add(JButton("Ok", actionPerformed = lambda e: messageFrame.dispose()), constraints) messageFrame.pack() messageFrame.visible = True print "BPROM Error:", "The pipeline will continue to run but BPROM did not process the request for promoters on the " + direction + " strand. Try again tomorrow" return [] else: return getPromoters()
class NewAccountGUI: def __init__(self, amgui): self.amgui = amgui self.am = amgui.acctmanager self.buildgwinfo() self.autologin = JCheckBox("Automatically Log In") self.acctname = JTextField() self.gwoptions = JPanel(doublebuffered) self.gwoptions.border = TitledBorder("Gateway Options") self.buildgwoptions("Twisted") self.mainframe = JFrame("New Account Window") self.buildpane() def buildgwinfo(self): self.gateways = { "Twisted": { "ident": JTextField(), "passwd": JPasswordField(), "host": JTextField("twistedmatrix.com"), "port": JTextField("8787"), "service": JTextField("twisted.words"), "persp": JTextField() }, "AIM": { "ident": JTextField(), "passwd": JPasswordField(), "host": JTextField("toc.oscar.aol.com"), "port": JTextField("9898") }, "IRC": { "ident": JTextField(), "passwd": JPasswordField(), "host": JTextField(), "port": JTextField("6667"), "channels": JTextField() } } self.displayorder = { "Twisted": [["Identity Name", "ident"], ["Password", "passwd"], ["Host", "host"], ["Port", "port"], ["Service Name", "service"], ["Perspective Name", "persp"]], "AIM": [["Screen Name", "ident"], ["Password", "passwd"], ["Host", "host"], ["Port", "port"]], "IRC": [["Nickname", "ident"], ["Password", "passwd"], ["Host", "host"], ["Port", "port"], ["Channels", "channels"]] } def buildgwoptions(self, gw): self.gwoptions.removeAll() self.gwoptions.layout = GridLayout(len(self.gateways[gw]), 2) for mapping in self.displayorder[gw]: self.gwoptions.add(JLabel(mapping[0])) self.gwoptions.add(self.gateways[gw][mapping[1]]) def buildpane(self): gw = JPanel(GridLayout(1, 2), doublebuffered) gw.add(JLabel("Gateway")) self.gwlist = JComboBox( self.gateways.keys()) #, actionPerformed=self.changegw) self.gwlist.setSelectedItem("Twisted") gw.add(self.gwlist) stdoptions = JPanel(GridLayout(2, 2), doublebuffered) stdoptions.border = TitledBorder("Standard Options") stdoptions.add(JLabel()) stdoptions.add(self.autologin) stdoptions.add(JLabel("Account Name")) stdoptions.add(self.acctname) buttons = JPanel(FlowLayout(), doublebuffered) buttons.add(JButton("OK", actionPerformed=self.addaccount)) buttons.add(JButton("Cancel", actionPerformed=self.cancel)) mainpane = self.mainframe.getContentPane() mainpane.layout = BoxLayout(mainpane, BoxLayout.Y_AXIS) mainpane.add(gw) mainpane.add(self.gwoptions) mainpane.add(stdoptions) mainpane.add(buttons) def show(self): self.mainframe.setLocation(100, 100) self.mainframe.pack() self.mainframe.show() #actionlisteners def changegw(self, ae): self.buildgwoptions(self.gwlist.getSelectedItem()) self.mainframe.pack() self.mainframe.show() def addaccount(self, ae): gwselection = self.gwlist.getSelectedItem() gw = self.gateways[gwselection] name = gw["ident"].text passwd = gw["passwd"].text host = gw["host"].text port = int(gw["port"].text) autologin = self.autologin.isSelected() acctname = self.acctname.text if gwselection == "Twisted": sname = gw["service"].text perspective = gw["persp"].text self.am.addAccount( PBAccount(acctname, autologin, name, passwd, host, port, [[stype, sname, perspective]])) elif gwselection == "AIM": self.am.addAccount( TOCAccount(acctname, autologin, name, passwd, host, port)) elif gwselection == "IRC": channels = gw["channels"].text self.am.addAccount( IRCAccount(acctname, autologin, name, passwd, host, port, channels)) self.amgui.update() print "Added new account" self.mainframe.dispose() def cancel(self, ae): print "Cancelling new account creation" self.mainframe.dispose()
class PropertyEditor(WindowAdapter): """ Edits Tabular Properties of a given WindowAdapter """ instances = {} last_location = None locations = {} last_size = None sizes = {} NEW_WINDOW_OFFSET = 32 offset = NEW_WINDOW_OFFSET @staticmethod def get_instance(text="Property Editor", columns=None, data=None, empty=None, add_actions=True, actions=None): """ Singleton Method based on the text property. It tries to generate only one property configuration page per text. :param text: getinstance key :param columns: proparty columns it should be an array alike :param data: it contains the current property rows :param empty: empty row property when adding a new one :param add_actions: include or not new actions :param actions: default set of actions to be appended to Add and Delete Rows :return: a new instance of PropertyEditor or a reused one. """ if not actions: actions = [] if not columns: columns = [] if data == None: data = [] if not empty: empty = [] try: PropertyEditor.instances[text] except KeyError: PropertyEditor.instances[text] = \ PropertyEditor().__private_init__(text, columns, data, empty, add_actions, actions) try: PropertyEditor.instances[text].this.setLocation( PropertyEditor.locations[text]) except KeyError: if PropertyEditor.last_location: PropertyEditor.instances[text].this.setLocation( PropertyEditor.last_location.x + PropertyEditor.offset, PropertyEditor.last_location.y + PropertyEditor.offset) PropertyEditor.offset = PropertyEditor.NEW_WINDOW_OFFSET try: PropertyEditor.instances[text].this.setSize( PropertyEditor.sizes[text]) except KeyError: if PropertyEditor.last_size: PropertyEditor.instances[text].this.setSize( PropertyEditor.last_size) PropertyEditor.last_location = PropertyEditor.instances[ text].this.getLocation() PropertyEditor.last_size = PropertyEditor.instances[ text].this.getSize() ## Hack ON: Bring on Front PropertyEditor.instances[text].this.setAlwaysOnTop(True) PropertyEditor.instances[text].this.setAlwaysOnTop(False) ## Hack OFF return PropertyEditor.instances[text] def __private_init__(self, text="Property Editor", columns=None, data=None, empty=None, add_actions=True, actions=None): if not actions: actions = [] if not columns: columns = [] if data == None: data = [] if not empty: empty = [] self._text = text self.this = JFrame(text) self._table = JTable() self._dtm = DefaultTableModel(0, 0) self._dtm.setColumnIdentifiers(columns) self._table.setModel(self._dtm) self._data = data for d in data: self._dtm.addRow(d) self._pane = JScrollPane(self._table) self.this.add(self._pane) self._empty = empty self.this.addWindowListener(self) self._dtm.addTableModelListener(lambda _: self._update_model()) self.this.setLocation(PropertyEditor.NEW_WINDOW_OFFSET, PropertyEditor.NEW_WINDOW_OFFSET) if add_actions: self._popup = JPopupMenu() self._pane.setComponentPopupMenu(self._popup) inherits_popup_menu(self._pane) self._actions = actions self._actions.append( ExecutorAction('Remove Selected Rows', action=lambda e: self._remove_row())) self._actions.append( ExecutorAction('Add New Row', action=lambda e: self._add_row())) for action in self._actions: self._popup.add(action.menuitem) self.this.setForeground(Color.black) self.this.setBackground(Color.lightGray) self.this.pack() self.this.setVisible(True) self.this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE) return self def _add_row(self): """ Add a new row the selection :return: None """ self._dtm.addRow(self._empty) def _remove_row(self): """ Remove all the selected rows from the selection :return: """ rows = self._table.getSelectedRows() for i in range(0, len(rows)): self._dtm.removeRow(rows[i] - i) def windowClosing(self, evt): """ Overrides WindowAdapter method :param evt: unused :return: None """ PropertyEditor.locations[self._text] = self.this.getLocation() PropertyEditor.sizes[self._text] = self.this.getSize() PropertyEditor.last_location = self.this.getLocation() PropertyEditor.last_size = self.this.getSize() PropertyEditor.offset = 0 self.this.setVisible(False) self.this.dispose() del PropertyEditor.instances[self._text] def _update_model(self): """ Update the data content with the updated rows :return: None """ del self._data[:] nRow = self._dtm.getRowCount() nCol = self._dtm.getColumnCount() for i in range(0, nRow): self._data.append([None] * nCol) for j in range(0, nCol): d = str(self._dtm.getValueAt(i, j)).lower() if d == 'none' or d == '': self._data[i][j] = None elif d == 'true' or d == 't': self._data[i][j] = True elif d == 'false' or d == 'f': self._data[i][j] = False else: try: self._data[i][j] = int(self._dtm.getValueAt(i, j)) except ValueError: self._data[i][j] = self._dtm.getValueAt(i, j)
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()
class BurpExtender(IBurpExtender, IContextMenuFactory): # Implement IBurpExtender def registerExtenderCallbacks(self, callbacks): self.printHeader() # Set extension name callbacks.setExtensionName("Directory Listing Parser for Burp Suite") # Callbacks object self._callbacks = callbacks # Helpers object self._helpers = callbacks.getHelpers() # Register a factory for custom context menu items callbacks.registerContextMenuFactory(self) return # Create a menu item if the appropriate section of the UI is selected def createMenuItems(self, invocation): menu = [] # Which part of the interface the user selects ctx = invocation.getInvocationContext() # Message Viewer Req/Res, Site Map Table, and Proxy History will show menu item if selected by the user if ctx == 2 or ctx == 3 or ctx == 4 or ctx == 5 or ctx == 6: menu.append(JMenuItem("Import Directory Listing", None, actionPerformed=lambda x, inv=invocation: self.openGUI(inv))) return menu if menu else None # Create and place GUI components on JFrame def openGUI(self, invocation): try: # Get values from request or response the extension is invoked from and prepopulate GUI values invMessage = invocation.getSelectedMessages() message = invMessage[0] originalHttpService = message.getHttpService() self.originalMsgProtocol = originalHttpService.getProtocol() self.originalMsgHost = originalHttpService.getHost() self.originalMsgPort = originalHttpService.getPort() except: self.originalMsgProtocol = '' self.originalMsgHost = '' self.originalMsgPort = '' try: self.cookies = self._callbacks.getCookieJarContents() self.cookie = '' except: pass self.SSL = 'http://' self.listType = '' self.parsedList = [] # Set up main window (JFrame) self.window = JFrame("Directory Listing Parser for Burp Suite", preferredSize=(600, 475), windowClosing=self.closeUI) self.window.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE) emptyBorder = BorderFactory.createEmptyBorder(10, 10, 10, 10) self.window.contentPane.setBorder(emptyBorder) self.window.contentPane.layout = BorderLayout() # Main window title placed at the top of the main window with an invisible bottom border titlePanel = JPanel() titleBorder = BorderFactory.createEmptyBorder(0, 0, 10, 0) title = JLabel("Directory Listing Parser for Burp Suite", JLabel.CENTER) title.setBorder(titleBorder) title.setFont(Font("Default", Font.PLAIN, 18)) titlePanel.add(title) self.window.contentPane.add("North", titlePanel) # Left panel for user input, consisting of hostname, directory prefix, ssl, port, type of listing, and file self.leftPanel = JPanel() self.leftPanel.layout = GridLayout(14, 1, 3, 3) hostnameLabel = JLabel("Hostname:") if self.originalMsgHost: self.hostnameTextField = JTextField(self.originalMsgHost.rstrip()) else: self.hostnameTextField = JTextField('Hostname') dirPrefixLabel = JLabel("Full Directory Prefix (Windows):") self.dirPrefixField = JTextField('C:\\var\www\\') sslLabel = JLabel("SSL:") self.radioBtnSslEnabled = JRadioButton('Enabled (https)', actionPerformed=self.radioSsl) self.radioBtnSslDisabled = JRadioButton('Disabled (http)', actionPerformed=self.radioSsl) sslButtonGroup = ButtonGroup() sslButtonGroup.add(self.radioBtnSslEnabled) sslButtonGroup.add(self.radioBtnSslDisabled) if self.originalMsgProtocol == "https": self.radioBtnSslEnabled.setSelected(True) else: self.radioBtnSslDisabled.setSelected(True) portLabel = JLabel("Port:") if self.originalMsgPort: self.portTextField = JTextField(str(self.originalMsgPort).rstrip()) else: self.portTextField = JTextField('80') osLabel = JLabel("Type of File Listing:") self.types = ('Windows \'dir /s\'', 'Linux \'ls -lR\'', 'Linux \'ls -R\'') self.comboListingType = JComboBox(self.types) uploadLabel = JLabel("Directory Listing File:") self.uploadTextField = JTextField('') uploadButton = JButton('Choose File', actionPerformed=self.chooseFile) self.leftPanel.add(hostnameLabel) self.leftPanel.add(self.hostnameTextField) self.leftPanel.add(dirPrefixLabel) self.leftPanel.add(self.dirPrefixField) self.leftPanel.add(sslLabel) self.leftPanel.add(self.radioBtnSslEnabled) self.leftPanel.add(self.radioBtnSslDisabled) self.leftPanel.add(portLabel) self.leftPanel.add(self.portTextField) self.leftPanel.add(osLabel) self.leftPanel.add(self.comboListingType) self.leftPanel.add(uploadLabel) self.leftPanel.add(self.uploadTextField) self.leftPanel.add(uploadButton) # Right panel consisting of a text area for the URL list self.UrlPanelLabel = JLabel("URL List:") self.textArea = JTextArea() self.textArea.setEditable(True) self.textArea.setFont(Font("Default", Font.PLAIN, 14)) if self.cookies: self.textArea.append('Cookies Found:\n') for cookie in self.cookies: if cookie.getDomain() in self.originalMsgHost: self.cookie += cookie.getName() + '=' + cookie.getValue() + '; ' self.textArea.append(cookie.getName() + '=' + cookie.getValue() + '\n') scrollArea = JScrollPane(self.textArea) scrollArea.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS) scrollArea.setPreferredSize(Dimension(400, 200)) self.rightPanel = JPanel() self.rightPanel.setLayout(BorderLayout(3, 3)) self.rightPanel.add(self.UrlPanelLabel, BorderLayout.NORTH) self.rightPanel.add(scrollArea, BorderLayout.CENTER) # Panel for the generate URL list and import URL list buttons generatePanel = JPanel() generatePanel.layout = BorderLayout(3, 3) generateButton = JButton('Generate URL List', actionPerformed=self.generateUrlList) importButton = JButton('Import URL List to Burp Site Map', actionPerformed=self.confirmImport) generatePanel.add("North", generateButton) generatePanel.add("South", importButton) self.rightPanel.add("South", generatePanel) # Add the two main panels to the left and right sides self.window.contentPane.add("East", self.rightPanel) self.window.contentPane.add("West", self.leftPanel) # Create a panel to be used for the file chooser window self.uploadPanel = JPanel() self.window.pack() self.window.show() # JFileChooser and showDialog for the user to specify their directory listing input file def chooseFile(self, event): chooseFile = JFileChooser() filter = FileNameExtensionFilter("c files", ["c"]) chooseFile.addChoosableFileFilter(filter) chooseFile.showDialog(self.uploadPanel, "Choose File") chosenFile = chooseFile.getSelectedFile() self.uploadTextField.text = str(chosenFile) # Set whether https is enabled. Default is disabled (http) def radioSsl(self, event): if self.radioBtnSslEnabled.isSelected(): self.SSL = 'https://' else: self.SSL = 'http://' # Create a parser object and pass the user's specified options. Retrieve the results and print them to a text area def generateUrlList(self, event): fileListingType = self.comboListingType.selectedIndex self.listType = self.types[fileListingType] urlsMade = 0 if os.path.isfile(self.uploadTextField.text): parser = ListingParser() parser.parse(self.hostnameTextField.getText(), self.dirPrefixField.getText().rstrip(), self.SSL, self.portTextField.getText(), self.listType, self.uploadTextField.getText()) self.parsedList = parser.returnList() self.textArea.setText('') for item in self.parsedList: self.textArea.append(item + '\n') urlsMade = str(len(self.parsedList)) if self.parsedList and urlsMade: self.textArea.append('\n' + 'Total Directories Found: ' + str(parser.directoryCount)) self.textArea.append('\n' + 'Total URLs Created: ' + urlsMade) else: self.textArea.append('Error occurred during parsing.\n') self.textArea.append('Please make sure the directory listing is a valid format and all input is correct.\n') self.textArea.append('E-mail [email protected] with errors or for further help.') else: JOptionPane.showMessageDialog(None, 'ERROR: File is not valid file or not found!') def closeUI(self, event): self.window.setVisible(False) self.window.dispose() # This is initiated by the user selecting the 'import to burp' button. Checks each generated URL for a valid response and adds it to the site map def importList(self): if self.parsedList: urlsAdded = 0 # Loop through each URL and check the response. If the response code is less than 404, add to site map for item in self.parsedList: # Pass exception if urlopen returns an http error if the URL is not reachable try: code = urlopen(item).code if code < 404: javaURL = URL(item) newRequest = self._helpers.buildHttpRequest(javaURL) stringNewRequest = self._helpers.bytesToString(newRequest).rstrip() if self.cookie: stringNewRequest += '\nCookie: ' + self.cookie.rstrip('; ') + '\r\n\r\n' requestResponse = self._callbacks.makeHttpRequest(self._helpers.buildHttpService(str(javaURL.getHost()), int(javaURL.getPort()), javaURL.getProtocol() == "https"), stringNewRequest) else: requestResponse = self._callbacks.makeHttpRequest(self._helpers.buildHttpService(str(javaURL.getHost()), int(javaURL.getPort()), javaURL.getProtocol() == "https"), newRequest) self._callbacks.addToSiteMap(requestResponse) urlsAdded += 1 except Exception, e: print e pass JOptionPane.showMessageDialog(None, str(urlsAdded) + " URL(s) added to Burp site map.") else:
class Config(ITab): """Defines the Configuration tab""" def __init__(self, callbacks, parent): # Initialze self stuff self._callbacks = callbacks self.config = {} self.ext_stats = {} self.url_reqs = [] self.parse_files = False self.tab = JPanel(GridBagLayout()) self.view_port_text = JTextArea("===SpyDir===") self.delim = JTextField(30) self.ext_white_list = JTextField(30) # I'm not sure if these fields are necessary still # why not just use Burp func to handle this? # leaving them in case I need it for the HTTP handler later # self.cookies = JTextField(30) # self.headers = JTextField(30) self.url = JTextField(30) self.parent_window = parent self.plugins = {} self.loaded_p_list = set() self.loaded_plugins = False self.config['Plugin Folder'] = None self.double_click = False self.source_input = "" self.print_stats = True self.curr_conf = JLabel() self.window = JFrame("Select plugins", preferredSize=(200, 250), windowClosing=self.p_close) self.window.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE) self.window.setVisible(False) # Initialize local stuff tab_constraints = GridBagConstraints() status_field = JScrollPane(self.view_port_text) # Configure view port self.view_port_text.setEditable(False) labels = self.build_ui() # Add things to rows tab_constraints.anchor = GridBagConstraints.FIRST_LINE_END tab_constraints.gridx = 1 tab_constraints.gridy = 0 tab_constraints.fill = GridBagConstraints.HORIZONTAL self.tab.add(JButton( "Resize screen", actionPerformed=self.resize), tab_constraints) tab_constraints.gridx = 0 tab_constraints.gridy = 1 tab_constraints.anchor = GridBagConstraints.FIRST_LINE_START self.tab.add(labels, tab_constraints) tab_constraints.gridx = 1 tab_constraints.gridy = 1 tab_constraints.fill = GridBagConstraints.BOTH tab_constraints.weightx = 1.0 tab_constraints.weighty = 1.0 tab_constraints.anchor = GridBagConstraints.FIRST_LINE_END self.tab.add(status_field, tab_constraints) try: self._callbacks.customizeUiComponent(self.tab) except Exception: pass def build_ui(self): """Builds the configuration screen""" labels = JPanel(GridLayout(21, 1)) checkbox = JCheckBox("Attempt to parse files for URL patterns?", False, actionPerformed=self.set_parse) stats_box = JCheckBox("Show stats?", True, actionPerformed=self.set_show_stats) # The two year old in me is laughing heartily plug_butt = JButton("Specify plugins location", actionPerformed=self.set_plugin_loc) load_plug_butt = JButton("Select plugins", actionPerformed=self.p_build_ui) parse_butt = JButton("Parse directory", actionPerformed=self.parse) clear_butt = JButton("Clear text", actionPerformed=self.clear) spider_butt = JButton("Send to Spider", actionPerformed=self.scan) save_butt = JButton("Save config", actionPerformed=self.save) rest_butt = JButton("Restore config", actionPerformed=self.restore) source_butt = JButton("Input Source File/Directory", actionPerformed=self.get_source_input) # Build grid labels.add(source_butt) labels.add(self.curr_conf) labels.add(JLabel("String Delimiter:")) labels.add(self.delim) labels.add(JLabel("Extension Whitelist:")) labels.add(self.ext_white_list) labels.add(JLabel("URL:")) labels.add(self.url) # Leaving these here for now. # labels.add(JLabel("Cookies:")) # labels.add(self.cookies) # labels.add(JLabel("HTTP Headers:")) # labels.add(self.headers) labels.add(checkbox) labels.add(stats_box) labels.add(plug_butt) labels.add(parse_butt) labels.add(JButton("Show all endpoints", actionPerformed=self.print_endpoints)) labels.add(clear_butt) labels.add(spider_butt) labels.add(JLabel("")) labels.add(save_butt) labels.add(rest_butt) labels.add(load_plug_butt) # Tool tips! self.delim.setToolTipText("Use to manipulate the final URL. " "See About tab for example.") self.ext_white_list.setToolTipText("Define a comma delimited list of" " file extensions to parse. Use *" " to parse all files.") self.url.setToolTipText("Enter the target URL") checkbox.setToolTipText("Parse files line by line using plugins" " to enumerate language/framework specific" " endpoints") parse_butt.setToolTipText("Attempt to enumerate application endpoints") clear_butt.setToolTipText("Clear status window and the parse results") spider_butt.setToolTipText("Process discovered endpoints") save_butt.setToolTipText("Saves the current config settings") rest_butt.setToolTipText("<html>Restores previous config settings:" "<br/>-Input Directory<br/>-String Delim" "<br/>-Ext WL<br/>-URL<br/>-Plugins") source_butt.setToolTipText("Select the application's " "source directory or file to parse") return labels def set_url(self, menu_url): """Changes the configuration URL to the one from the menu event""" self.url.setText(menu_url) # Event functions def set_parse(self, event): """ Handles the click event from the UI checkbox to attempt code level parsing """ self.parse_files = not self.parse_files if self.parse_files: if not self.loaded_plugins: self._plugins_missing_warning() def restore(self, event): """Attempts to restore the previously saved configuration.""" jdump = None try: jdump = loads(self._callbacks.loadExtensionSetting("config")) except Exception as exc: # Generic exception thrown directly to user self.update_scroll( "[!!] Error during restore!\n\tException: %s" % str(exc)) if jdump is not None: self.url.setText(jdump.get('URL')) # self.cookies.setText(jdump.get('Cookies')) # self.headers.setText(jdump.get("Headers")) ewl = "" for ext in jdump.get('Extension Whitelist'): ewl += ext + ", " self.ext_white_list.setText(ewl[:-2]) self.delim.setText(jdump.get('String Delimiter')) self.source_input = jdump.get("Input Directory") self.config['Plugin Folder'] = jdump.get("Plugin Folder") if (self.config['Plugin Folder'] is not None and (len(self.plugins.values()) < 1)): self._load_plugins(self.config['Plugin Folder']) self._update() self.update_scroll("[^] Restore complete!") else: self.update_scroll("[!!] Restore failed!") def save(self, event=None): """ Saves the configuration details to a Burp Suite's persistent store. """ self._update() try: if not self._callbacks.isInScope(URL(self.url.getText())): self.update_scroll("[!!] URL provided is NOT in Burp Scope!") except MalformedURLException: # If url field is blank we'll pass # still save the settings. try: self._callbacks.saveExtensionSetting("config", dumps(self.config)) self.update_scroll("[^] Settings saved!") except Exception: self.update_scroll("[!!] Error saving settings to Burp Suite!") def parse(self, event): """ Handles the click event from the UI. Attempts to parse the given directory (and/or source files) for url endpoints Saves the items found within the url_reqs list """ self._update() file_set = set() fcount = 0 other_dirs = set() self.ext_stats = {} if self.loaded_plugins: self.update_scroll("[^] Attempting to parse files" + " for URL patterns. This might take a minute.") if path.isdir(self.source_input): for dirname, _, filenames in walk(self.source_input): for filename in filenames: fcount += 1 ext = path.splitext(filename)[1] count = self.ext_stats.get(ext, 0) + 1 filename = "%s/%s" % (dirname, filename) self.ext_stats.update({ext: count}) if self.parse_files: # i can haz threading? file_set.update(self._code_as_endpoints(filename, ext)) elif self._ext_test(ext): r_files, oths = self._files_as_endpoints(filename, ext) file_set.update(r_files) other_dirs.update(oths) elif path.isfile(self.source_input): ext = path.splitext(self.source_input)[1] file_set.update(self._code_as_endpoints(self.source_input, ext)) else: self.update_scroll("[!!] Input Directory is not valid!") if len(other_dirs) > 0: self.update_scroll("[*] Found files matching file extension in:\n") for other_dir in other_dirs: self.update_scroll(" " * 4 + "%s\n" % other_dir) for item in file_set: if item.startswith("http://") or item.startswith("https://"): proto = item.split("//")[0] + '//' item = item.replace(proto, "") self.url_reqs.append(proto + item.replace('//', '/')) self._print_parsed_status(fcount) return (other_dirs, self.url_reqs) def scan(self, event): """ handles the click event from the UI. Adds the given URL to the burp scope and sends the requests to the burp spider """ temp_url = self.url.getText() if not self._callbacks.isInScope(URL(temp_url)): if not self.double_click: self.update_scroll("[!!] URL is not in scope! Press Send to " "Spider again to add to scope and scan!") self.double_click = True return else: self._callbacks.sendToSpider(URL(temp_url)) self.update_scroll( "[^] Sending %d requests to Spider" % len(self.url_reqs)) for req in self.url_reqs: self._callbacks.sendToSpider(URL(req)) def clear(self, event): """Clears the viewport and the current parse exts""" self.view_port_text.setText("===SpyDir===") self.ext_stats = {} def print_endpoints(self, event): """Prints the discovered endpoints to the status window.""" req_str = "" if len(self.url_reqs) > 0: self.update_scroll("[*] Printing all discovered endpoints:") for req in self.url_reqs: req_str += " %s\n" % req else: req_str = "[!!] No endpoints discovered" self.update_scroll(req_str) def set_show_stats(self, event): """Modifies the show stats setting""" self.print_stats = not self.print_stats def get_source_input(self, event): """Sets the source dir/file for parsing""" source_chooser = JFileChooser() source_chooser.setFileSelectionMode( JFileChooser.FILES_AND_DIRECTORIES) source_chooser.showDialog(self.tab, "Choose Source Location") chosen_source = source_chooser.getSelectedFile() try: self.source_input = chosen_source.getAbsolutePath() except AttributeError: pass if self.source_input is not None: self.update_scroll("[*] Source location: %s" % self.source_input) self.curr_conf.setText(self.source_input) # Plugin functions def _parse_file(self, filename, file_url): """ Attempts to parse a file with the loaded plugins Returns set of endpoints """ file_set = set() with open(filename, 'r') as plug_in: lines = plug_in.readlines() ext = path.splitext(filename)[1].upper() if ext in self.plugins.keys(): for plug in self.plugins.get(ext): if plug.enabled: res = plug.run(lines) if len(res) > 0: for i in res: i = file_url + i file_set.add(i) elif ext == '.TXT' and self._ext_test(ext): for i in lines: i = file_url + i file_set.add(i.strip()) return file_set def set_plugin_loc(self, event): """Attempts to load plugins from a specified location""" if self.config['Plugin Folder'] is not None: choose_plugin_location = JFileChooser(self.config['Plugin Folder']) else: choose_plugin_location = JFileChooser() choose_plugin_location.setFileSelectionMode( JFileChooser.DIRECTORIES_ONLY) choose_plugin_location.showDialog(self.tab, "Choose Folder") chosen_folder = choose_plugin_location.getSelectedFile() self.config['Plugin Folder'] = chosen_folder.getAbsolutePath() self._load_plugins(self.config['Plugin Folder']) def _load_plugins(self, folder): """ Parses a local directory to get the plugins related to code level scanning """ report = "" if len(self.plugins.keys()) > 0: report = "[^] Plugins reloaded!" for _, _, filenames in walk(folder): for p_name in filenames: n_e = path.splitext(p_name) # n_e = name_extension if n_e[1] == ".py": f_loc = "%s/%s" % (folder, p_name) loaded_plug = self._validate_plugin(n_e[0], f_loc) if loaded_plug: self.loaded_p_list.add(loaded_plug) if not report.startswith("[^]"): report += "%s loaded\n" % loaded_plug.get_name() self._dictify(self.loaded_p_list) if len(self.plugins.keys()) > 0: self.loaded_plugins = True else: report = "[!!] Plugins load failure" self.loaded_plugins = False self.update_scroll(report) return report def _validate_plugin(self, p_name, f_loc): """ Attempts to verify the manditory plugin functions to prevent broken plugins from loading. Generates an error message if plugin does not contain an appropriate function. """ # Load the plugin try: plug = load_source(p_name, f_loc) except Exception as exc: # this needs to be generic. self.update_scroll( "[!!] Error loading: %s\n\tType:%s Error: %s" % (f_loc, type(exc), str(exc))) # Verify the plugin's functions funcs = dir(plug) err = [] if "get_name" not in funcs: err.append("get_name()") if "get_ext" not in funcs: err.append("get_ext()") if "run" not in funcs: err.append("run()") # Report errors & return if len(err) < 1: return Plugin(plug, True) else: for issue in err: self.update_scroll("[!!] %s is missing: %s func" % (p_name, issue)) return None def _dictify(self, plist): """Converts the list of loaded plugins (plist) into a dictionary""" for p in plist: exts = p.get_ext().upper() for ext in exts.split(","): prev_load = self.plugins.get(ext, []) prev_load.append(p) self.plugins[ext] = prev_load # Status window functions def _print_parsed_status(self, fcount): """Prints the parsed directory status information""" if self.parse_files and not self.loaded_plugins: self._plugins_missing_warning() if len(self.url_reqs) > 0: self.update_scroll("[*] Example URL: %s" % self.url_reqs[0]) if self.print_stats: report = (("[*] Found: %r files to be requested.\n\n" + "[*] Stats: \n " + "Found: %r files.\n") % (len(self.url_reqs), fcount)) if len(self.ext_stats) > 0: report += ("[*] Extensions found: %s" % str(dumps(self.ext_stats, sort_keys=True, indent=4))) else: report = ("[*] Found: %r files to be requested.\n" % len(self.url_reqs)) self.update_scroll(report) return report def _plugins_missing_warning(self): """Prints a warning message""" self.update_scroll("[!!] No plugins loaded!") def update_scroll(self, text): """Updates the view_port_text with the new information""" temp = self.view_port_text.getText().strip() if text not in temp or text[0:4] == "[!!]": self.view_port_text.setText("%s\n%s" % (temp, text)) elif not temp.endswith("[^] Status unchanged"): self.view_port_text.setText("%s\n[^] Status unchanged" % temp) # Internal functions def _code_as_endpoints(self, filename, ext): file_set = set() file_url = self.config.get("URL") if self.loaded_plugins: if self._ext_test(ext): file_set.update( self._parse_file(filename, file_url)) else: file_set.update( self._parse_file(filename, file_url)) return file_set def _files_as_endpoints(self, filename, ext): """Generates endpoints via files with the appropriate extension(s)""" file_url = self.config.get("URL") broken_splt = "" other_dirs = set() # directories outside of the String Delim. file_set = set() str_del = self.config.get("String Delimiter") if not str_del: self.update_scroll("[!!] No available String Delimiter!") return spl_str = filename.split(str_del) try: # Fix for index out of bounds exception while parsing # subfolders _not_ included by the split if len(spl_str) > 1: file_url += ((spl_str[1]) .replace('\\', '/')) else: broken_splt = filename.split(self.source_input)[1] other_dirs.add(broken_splt) except Exception as exc: # Generic exception thrown directly to user self.update_scroll("[!!] Error parsing: " + "%s\n\tException: %s" % (filename, str(exc))) if self._ext_test(ext): if file_url != self.config.get("URL"): file_set.add(file_url) else: other_dirs.discard(broken_splt) return file_set, other_dirs def _ext_test(self, ext): """Litmus test for extension whitelist""" val = False if len(self.config.get("Extension Whitelist")) > 0: val = (len(ext) > 0 and (ext.strip().upper() in self.config.get("Extension Whitelist"))) elif "*" in self.config.get("Extension Whitelist"): val = True return val def _update(self): """Updates internal data""" self.config["Input Directory"] = self.source_input self.config["String Delimiter"] = self.delim.getText() white_list_text = self.ext_white_list.getText() self.config["Extension Whitelist"] = white_list_text.upper().split(',') file_url = self.url.getText() if not file_url.endswith('/') and file_url != "": file_url += '/' self.config["URL"] = file_url # self.config["Cookies"] = self.cookies.getText() # self.config["Headers"] = self.headers.getText() del self.url_reqs[:] self.curr_conf.setText(self.source_input) # Window sizing functions def resize(self, event): """Resizes the window to better fit Burp""" if self.parent_window is not None: par_size = self.parent_window.getSize() par_size.setSize(par_size.getWidth() * .99, par_size.getHeight() * .9) self.tab.setPreferredSize(par_size) self.parent_window.validate() self.parent_window.switch_focus() def p_close(self, event): """ Handles the window close event. """ self.window.setVisible(False) self.window.dispose() def p_build_ui(self, event): """ Adds a list of checkboxes, one for each loaded plugin to the Selct plugins window """ if not self.loaded_p_list: self.update_scroll("[!!] No plugins loaded!") return scroll_pane = JScrollPane() scroll_pane.setPreferredSize(Dimension(200, 250)) check_frame = JPanel(GridBagLayout()) constraints = GridBagConstraints() constraints.fill = GridBagConstraints.HORIZONTAL constraints.gridy = 0 constraints.anchor = GridBagConstraints.FIRST_LINE_START for plug in self.loaded_p_list: check_frame.add(JCheckBox(plug.get_name(), plug.enabled, actionPerformed=self.update_box), constraints) constraints.gridy += 1 vport = JViewport() vport.setView(check_frame) scroll_pane.setViewport(vport) self.window.contentPane.add(scroll_pane) self.window.pack() self.window.setVisible(True) def update_box(self, event): """ Handles the check/uncheck event for the plugin's box. """ for plug in self.loaded_p_list: if plug.get_name() == event.getActionCommand(): plug.enabled = not plug.enabled if plug.enabled: self.update_scroll("[^] Enabled: %s" % event.getActionCommand()) else: self.update_scroll("[^] Disabled: %s" % event.getActionCommand()) # ITab required functions @staticmethod def getTabCaption(): """Returns the name of the Burp Suite Tab""" return "SpyDir" def getUiComponent(self): """Returns the UI component for the Burp Suite tab""" return self.tab
class MenueFrame(object): def __init__(self): self.mainDir = "" self.frame = JFrame("Dots Quality Check", size=(250,300)) self.frame.setLocation(20,120) self.Panel = JPanel(GridLayout(0,1)) self.frame.add(self.Panel) self.openNextButton = JButton('Open Next Random',actionPerformed=openRandom) self.Panel.add(self.openNextButton) self.saveButton = JButton('Save',actionPerformed=save) self.saveButton.setEnabled(False) self.Panel.add(self.saveButton) self.cropButton = JButton('Crop values from here', actionPerformed=cropVals) self.Panel.add(self.cropButton) self.DiscardButton = JButton('Discard cell', actionPerformed=discardCell) self.DiscardButton.setEnabled(True) self.Panel.add(self.DiscardButton) self.quitButton = JButton('Quit script',actionPerformed=quit) self.Panel.add(self.quitButton) annoPanel = JPanel() #add gridlayout wtRButton = JRadioButton("wt", actionCommand="wt") defectRButton = JRadioButton("Defect", actionCommand="defect") annoPanel.add(wtRButton) annoPanel.add(defectRButton) self.aButtonGroup = ButtonGroup() self.aButtonGroup.add(wtRButton) self.aButtonGroup.add(defectRButton) self.Panel.add(annoPanel) self.ProgBar = JProgressBar() self.ProgBar.setStringPainted(True) self.ProgBar.setValue(0) self.Panel.add(self.ProgBar) self.pathLabel = JLabel("-- No main directory chosen --") self.pathLabel.setHorizontalAlignment( SwingConstants.CENTER ) self.Panel.add(self.pathLabel) WindowManager.addWindow(self.frame) self.show() def show(self): self.frame.visible = True def getFrame(self): return self.frame def setSaveActive(self): self.saveButton.setEnabled(True) self.show() def setSaveInactive(self): self.saveButton.setEnabled(False) self.show() def setMainDir(self, path): self.mainDir = path self.pathLabel.setText("MainDir: " + os.path.basename(os.path.split(self.mainDir)[0])) def getMainDir(self): return self.mainDir def setProgBarMax(self, maximum): self.ProgBar.setMaximum(maximum) def setProgBarVal(self, value): self.ProgBar.setValue(value) def close(): WindowManager.removeWindow(self.frame) self.frame.dispose()
# Ensure we have an APIKEY elif APIKEY == "": show_error_message("VirusTotal API key must be set.") # Initial checks good, lets run the script else: global cancelled cancelled = False # Do some UI setup here to keep the main() method a little easier to read jframe = JFrame("VirusTotal Integration", defaultCloseOperation=JFrame.DISPOSE_ON_CLOSE, size=(300, 100), locationRelativeTo=None) jframe.setUndecorated(True) statusLabel = JLabel("", JLabel.CENTER) jframe.setResizable(False) jframe.setLayout(GridLayout(3, 1)) statusLabel.setSize(300, 50) jframe.getContentPane().add(statusLabel) jbutton = JButton('Cancel') jbutton.addActionListener(cancel) # Run the main code function result = main() # Clean up jframe and show the result message jframe.setVisible(False) jframe.dispose() if result: JOptionPane.showMessageDialog(None, result)
] nbButtons = len(buttons) win = JFrame("Music Player") win.getContentPane().setLayout(FlowLayout()) for i in range(nbButtons): win.getContentPane().add(buttons[i]) win.getContentPane().add(status) win.setTitle("Music Player") win.setSize(700, 100) win.setLocation(200, 100) win.setVisible(True) status.setText("Please open a WAV music file") doDisplayTime = True # Display loop while (win.isVisible()): if player != None: if doDisplayTime: status.setText("Current time: " + getClipTime()) else: status.setText("Current volume: " + str(volume)) SoundPlayer.delay(300) doDisplayTime = True SoundPlayer.delay(100) # Cleanup if player != None: player.stop() win.dispose() # free resources
class Config(ITab): """Defines the Configuration tab""" def __init__(self, callbacks, parent): # Initialze self stuff self._callbacks = callbacks self.config = {} self.ext_stats = {} self.url_reqs = [] self.parse_files = False self.tab = JPanel(GridBagLayout()) self.view_port_text = JTextArea("===SpyDir===") self.delim = JTextField(30) self.ext_white_list = JTextField(30) # I'm not sure if these fields are necessary still # why not just use Burp func to handle this? # leaving them in case I need it for the HTTP handler later # self.cookies = JTextField(30) # self.headers = JTextField(30) self.url = JTextField(30) self.parent_window = parent self.plugins = {} self.loaded_p_list = set() self.loaded_plugins = False self.config['Plugin Folder'] = None self.double_click = False self.source_input = "" self.print_stats = True self.curr_conf = JLabel() self.window = JFrame("Select plugins", preferredSize=(200, 250), windowClosing=self.p_close) self.window.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE) self.window.setVisible(False) self.path_vars = JTextField(30) # Initialize local stuff tab_constraints = GridBagConstraints() status_field = JScrollPane(self.view_port_text) # Configure view port self.view_port_text.setEditable(False) labels = self.build_ui() # Add things to rows tab_constraints.anchor = GridBagConstraints.FIRST_LINE_END tab_constraints.gridx = 1 tab_constraints.gridy = 0 tab_constraints.fill = GridBagConstraints.HORIZONTAL self.tab.add(JButton( "Resize screen", actionPerformed=self.resize), tab_constraints) tab_constraints.gridx = 0 tab_constraints.gridy = 1 tab_constraints.anchor = GridBagConstraints.FIRST_LINE_START self.tab.add(labels, tab_constraints) tab_constraints.gridx = 1 tab_constraints.gridy = 1 tab_constraints.fill = GridBagConstraints.BOTH tab_constraints.weightx = 1.0 tab_constraints.weighty = 1.0 tab_constraints.anchor = GridBagConstraints.FIRST_LINE_END self.tab.add(status_field, tab_constraints) try: self._callbacks.customizeUiComponent(self.tab) except Exception: pass def build_ui(self): """Builds the configuration screen""" labels = JPanel(GridLayout(21, 1)) checkbox = JCheckBox("Attempt to parse files for URL patterns?", False, actionPerformed=self.set_parse) stats_box = JCheckBox("Show stats?", True, actionPerformed=self.set_show_stats) # The two year old in me is laughing heartily plug_butt = JButton("Specify plugins location", actionPerformed=self.set_plugin_loc) load_plug_butt = JButton("Select plugins", actionPerformed=self.p_build_ui) parse_butt = JButton("Parse directory", actionPerformed=self.parse) clear_butt = JButton("Clear text", actionPerformed=self.clear) spider_butt = JButton("Send to Spider", actionPerformed=self.scan) save_butt = JButton("Save config", actionPerformed=self.save) rest_butt = JButton("Restore config", actionPerformed=self.restore) source_butt = JButton("Input Source File/Directory", actionPerformed=self.get_source_input) # Build grid labels.add(source_butt) labels.add(self.curr_conf) labels.add(JLabel("String Delimiter:")) labels.add(self.delim) labels.add(JLabel("Extension Whitelist:")) labels.add(self.ext_white_list) labels.add(JLabel("URL:")) labels.add(self.url) labels.add(JLabel("Path Variables")) labels.add(self.path_vars) # Leaving these here for now. # labels.add(JLabel("Cookies:")) # labels.add(self.cookies) # labels.add(JLabel("HTTP Headers:")) # labels.add(self.headers) labels.add(checkbox) labels.add(stats_box) labels.add(plug_butt) labels.add(parse_butt) labels.add(JButton("Show all endpoints", actionPerformed=self.print_endpoints)) labels.add(clear_butt) labels.add(spider_butt) labels.add(JLabel("")) labels.add(save_butt) labels.add(rest_butt) labels.add(load_plug_butt) # Tool tips! self.delim.setToolTipText("Use to manipulate the final URL. " "See About tab for example.") self.ext_white_list.setToolTipText("Define a comma delimited list of" " file extensions to parse. Use *" " to parse all files.") self.url.setToolTipText("Enter the target URL") checkbox.setToolTipText("Parse files line by line using plugins" " to enumerate language/framework specific" " endpoints") parse_butt.setToolTipText("Attempt to enumerate application endpoints") clear_butt.setToolTipText("Clear status window and the parse results") spider_butt.setToolTipText("Process discovered endpoints") save_butt.setToolTipText("Saves the current config settings") rest_butt.setToolTipText("<html>Restores previous config settings:" "<br/>-Input Directory<br/>-String Delim" "<br/>-Ext WL<br/>-URL<br/>-Plugins") source_butt.setToolTipText("Select the application's " "source directory or file to parse") self.path_vars.setToolTipText("Supply a JSON object with values" "for dynamically enumerated query" "string variables") return labels def set_url(self, menu_url): """Changes the configuration URL to the one from the menu event""" self.url.setText(menu_url) # Event functions def set_parse(self, event): """ Handles the click event from the UI checkbox to attempt code level parsing """ self.parse_files = not self.parse_files if self.parse_files: if not self.loaded_plugins: self._plugins_missing_warning() def restore(self, event): """Attempts to restore the previously saved configuration.""" jdump = None try: jdump = loads(self._callbacks.loadExtensionSetting("config")) except Exception as exc: # Generic exception thrown directly to user self.update_scroll( "[!!] Error during restore!\n\tException: %s" % str(exc)) if jdump is not None: self.url.setText(jdump.get('URL')) # self.cookies.setText(jdump.get('Cookies')) # self.headers.setText(jdump.get("Headers")) ewl = "" for ext in jdump.get('Extension Whitelist'): ewl += ext + ", " self.ext_white_list.setText(ewl[:-2]) self.delim.setText(jdump.get('String Delimiter')) self.source_input = jdump.get("Input Directory") self.config['Plugin Folder'] = jdump.get("Plugin Folder") if (self.config['Plugin Folder'] is not None and (len(self.plugins.values()) < 1)): self._load_plugins(self.config['Plugin Folder']) self._update() self.update_scroll("[^] Restore complete!") else: self.update_scroll("[!!] Restore failed!") def save(self, event=None): """ Saves the configuration details to a Burp Suite's persistent store. """ self._update() try: if not self._callbacks.isInScope(URL(self.url.getText())): self.update_scroll("[!!] URL provided is NOT in Burp Scope!") except MalformedURLException: # If url field is blank we'll pass # still save the settings. try: self._callbacks.saveExtensionSetting("config", dumps(self.config)) self.update_scroll("[^] Settings saved!") except Exception: self.update_scroll("[!!] Error saving settings to Burp Suite!") def parse(self, event): """ Handles the click event from the UI. Attempts to parse the given directory (and/or source files) for url endpoints Saves the items found within the url_reqs list """ self._update() file_set = set() fcount = 0 other_dirs = set() self.ext_stats = {} if self.loaded_plugins: self.update_scroll("[^] Attempting to parse files" + " for URL patterns. This might take a minute.") if path.isdir(self.source_input): for dirname, _, filenames in walk(self.source_input): for filename in filenames: fcount += 1 ext = path.splitext(filename)[1] count = self.ext_stats.get(ext, 0) + 1 filename = "%s/%s" % (dirname, filename) self.ext_stats.update({ext: count}) if self.parse_files and self._ext_test(ext): # i can haz threading? file_set.update(self._code_as_endpoints(filename, ext)) elif self._ext_test(ext): r_files, oths = self._files_as_endpoints(filename, ext) file_set.update(r_files) other_dirs.update(oths) elif path.isfile(self.source_input): ext = path.splitext(self.source_input)[1] file_set.update(self._code_as_endpoints(self.source_input, ext)) else: self.update_scroll("[!!] Input Directory is not valid!") if len(other_dirs) > 0: self.update_scroll("[*] Found files matching file extension in:\n") for other_dir in other_dirs: self.update_scroll(" " * 4 + "%s\n" % other_dir) self._handle_path_vars(file_set) self._print_parsed_status(fcount) return (other_dirs, self.url_reqs) def _handle_path_vars(self, file_set): proto = 'http://' for item in file_set: if item.startswith("http://") or item.startswith("https://"): proto = item.split("//")[0] + '//' item = item.replace(proto, "") item = self._path_vars(item) self.url_reqs.append(proto + item.replace('//', '/')) def _path_vars(self, item): p_vars = None if self.path_vars.getText(): try: p_vars = loads(str(self.path_vars.getText())) except: self.update_scroll("[!] Error reading supplied Path Variables!") if p_vars is not None: rep_str = "" try: for k in p_vars.keys(): rep_str += "[^] Replacing %s with %s!\n" % (k, str(p_vars.get(k))) self.update_scroll(rep_str) for k in p_vars.keys(): if str(k) in item: item = item.replace(k, str(p_vars.get(k))) except AttributeError: self.update_scroll("[!] Error reading supplied Path Variables! This needs to be a JSON dictionary!") return item def scan(self, event): """ handles the click event from the UI. Adds the given URL to the burp scope and sends the requests to the burp spider """ temp_url = self.url.getText() if not self._callbacks.isInScope(URL(temp_url)): if not self.double_click: self.update_scroll("[!!] URL is not in scope! Press Send to " "Spider again to add to scope and scan!") self.double_click = True return else: self._callbacks.sendToSpider(URL(temp_url)) self.update_scroll( "[^] Sending %d requests to Spider" % len(self.url_reqs)) for req in self.url_reqs: self._callbacks.sendToSpider(URL(req)) def clear(self, event): """Clears the viewport and the current parse exts""" self.view_port_text.setText("===SpyDir===") self.ext_stats = {} def print_endpoints(self, event): """Prints the discovered endpoints to the status window.""" req_str = "" if len(self.url_reqs) > 0: self.update_scroll("[*] Printing all discovered endpoints:") for req in sorted(self.url_reqs): req_str += " %s\n" % req else: req_str = "[!!] No endpoints discovered" self.update_scroll(req_str) def set_show_stats(self, event): """Modifies the show stats setting""" self.print_stats = not self.print_stats def get_source_input(self, event): """Sets the source dir/file for parsing""" source_chooser = JFileChooser() source_chooser.setFileSelectionMode( JFileChooser.FILES_AND_DIRECTORIES) source_chooser.showDialog(self.tab, "Choose Source Location") chosen_source = source_chooser.getSelectedFile() try: self.source_input = chosen_source.getAbsolutePath() except AttributeError: pass if self.source_input is not None: self.update_scroll("[*] Source location: %s" % self.source_input) self.curr_conf.setText(self.source_input) # Plugin functions def _parse_file(self, filename, file_url): """ Attempts to parse a file with the loaded plugins Returns set of endpoints """ file_set = set() with open(filename, 'r') as plug_in: lines = plug_in.readlines() ext = path.splitext(filename)[1].upper() if ext in self.plugins.keys() and self._ext_test(ext): for plug in self.plugins.get(ext): if plug.enabled: res = plug.run(lines) if len(res) > 0: for i in res: i = file_url + i file_set.add(i) elif ext == '.TXT' and self._ext_test(ext): for i in lines: i = file_url + i file_set.add(i.strip()) return file_set def set_plugin_loc(self, event): """Attempts to load plugins from a specified location""" if self.config['Plugin Folder'] is not None: choose_plugin_location = JFileChooser(self.config['Plugin Folder']) else: choose_plugin_location = JFileChooser() choose_plugin_location.setFileSelectionMode( JFileChooser.DIRECTORIES_ONLY) choose_plugin_location.showDialog(self.tab, "Choose Folder") chosen_folder = choose_plugin_location.getSelectedFile() self.config['Plugin Folder'] = chosen_folder.getAbsolutePath() self._load_plugins(self.config['Plugin Folder']) def _load_plugins(self, folder): """ Parses a local directory to get the plugins related to code level scanning """ report = "" if len(self.plugins.keys()) > 0: report = "[^] Plugins reloaded!" for _, _, filenames in walk(folder): for p_name in filenames: n_e = path.splitext(p_name) # n_e = name_extension if n_e[1] == ".py": f_loc = "%s/%s" % (folder, p_name) loaded_plug = self._validate_plugin(n_e[0], f_loc) if loaded_plug: for p in self.loaded_p_list: if p.get_name() == loaded_plug.get_name(): self.loaded_p_list.discard(p) self.loaded_p_list.add(loaded_plug) if not report.startswith("[^]"): report += "%s loaded\n" % loaded_plug.get_name() self._dictify(self.loaded_p_list) if len(self.plugins.keys()) > 0: self.loaded_plugins = True else: report = "[!!] Plugins load failure" self.loaded_plugins = False self.update_scroll(report) return report def _validate_plugin(self, p_name, f_loc): """ Attempts to verify the manditory plugin functions to prevent broken plugins from loading. Generates an error message if plugin does not contain an appropriate function. """ # Load the plugin try: plug = load_source(p_name, f_loc) except Exception as exc: # this needs to be generic. self.update_scroll( "[!!] Error loading: %s\n\tType:%s Error: %s" % (f_loc, type(exc), str(exc))) # Verify the plugin's functions funcs = dir(plug) err = [] if "get_name" not in funcs: err.append("get_name()") if "get_ext" not in funcs: err.append("get_ext()") if "run" not in funcs: err.append("run()") # Report errors & return if len(err) < 1: return Plugin(plug, True) for issue in err: self.update_scroll("[!!] %s is missing: %s func" % (p_name, issue)) return None def _dictify(self, plist): """Converts the list of loaded plugins (plist) into a dictionary""" for p in plist: exts = p.get_ext().upper() for ext in exts.split(","): prev_load = self.plugins.get(ext, []) prev_load.append(p) self.plugins[ext] = prev_load # Status window functions def _print_parsed_status(self, fcount): """Prints the parsed directory status information""" if self.parse_files and not self.loaded_plugins: self._plugins_missing_warning() if len(self.url_reqs) > 0: self.update_scroll("[*] Example URL: %s" % self.url_reqs[0]) if self.print_stats: report = (("[*] Found: %r files to be requested.\n\n" + "[*] Stats: \n " + "Found: %r files.\n") % (len(self.url_reqs), fcount)) if len(self.ext_stats) > 0: report += ("[*] Extensions found: %s" % str(dumps(self.ext_stats, sort_keys=True, indent=4))) else: report = ("[*] Found: %r files to be requested.\n" % len(self.url_reqs)) self.update_scroll(report) return report def _plugins_missing_warning(self): """Prints a warning message""" self.update_scroll("[!!] No plugins loaded!") def update_scroll(self, text): """Updates the view_port_text with the new information""" temp = self.view_port_text.getText().strip() if text not in temp or text[0:4] == "[!!]": self.view_port_text.setText("%s\n%s" % (temp, text)) elif not temp.endswith("[^] Status unchanged"): self.view_port_text.setText("%s\n[^] Status unchanged" % temp) # Internal functions def _code_as_endpoints(self, filename, ext): file_set = set() file_url = self.config.get("URL") if self.loaded_plugins or ext == '.txt': if self._ext_test(ext): file_set.update( self._parse_file(filename, file_url)) else: file_set.update( self._parse_file(filename, file_url)) return file_set def _files_as_endpoints(self, filename, ext): """Generates endpoints via files with the appropriate extension(s)""" file_url = self.config.get("URL") broken_splt = "" other_dirs = set() # directories outside of the String Delim. file_set = set() str_del = self.config.get("String Delimiter") if not str_del: self.update_scroll("[!!] No available String Delimiter!") return spl_str = filename.split(str_del) try: # Fix for index out of bounds exception while parsing # subfolders _not_ included by the split if len(spl_str) > 1: file_url += ((spl_str[1]) .replace('\\', '/')) else: broken_splt = filename.split(self.source_input)[1] other_dirs.add(broken_splt) except Exception as exc: # Generic exception thrown directly to user self.update_scroll("[!!] Error parsing: " + "%s\n\tException: %s" % (filename, str(exc))) if self._ext_test(ext): if file_url != self.config.get("URL"): file_set.add(file_url) else: other_dirs.discard(broken_splt) return file_set, other_dirs def _ext_test(self, ext): """Litmus test for extension whitelist""" val = False if "*" in self.config.get("Extension Whitelist"): val = True else: val = (len(ext) > 0 and (ext.strip().upper() in self.config.get("Extension Whitelist"))) return val def _update(self): """Updates internal data""" self.config["Input Directory"] = self.source_input self.config["String Delimiter"] = self.delim.getText() white_list_text = self.ext_white_list.getText() self.config["Extension Whitelist"] = white_list_text.upper().split(',') file_url = self.url.getText() if not (file_url.startswith('https://') or file_url.startswith('http://')): self.update_scroll("[!] Assuming protocol! Default value: 'http://'") file_url = 'http://' + file_url self.url.setText(file_url) if not file_url.endswith('/') and file_url != "": file_url += '/' self.config["URL"] = file_url # self.config["Cookies"] = self.cookies.getText() # self.config["Headers"] = self.headers.getText() del self.url_reqs[:] self.curr_conf.setText(self.source_input) # Window sizing functions def resize(self, event): """Resizes the window to better fit Burp""" if self.parent_window is not None: par_size = self.parent_window.getSize() par_size.setSize(par_size.getWidth() * .99, par_size.getHeight() * .9) self.tab.setPreferredSize(par_size) self.parent_window.validate() self.parent_window.switch_focus() def p_close(self, event): """ Handles the window close event. """ self.window.setVisible(False) self.window.dispose() def p_build_ui(self, event): """ Adds a list of checkboxes, one for each loaded plugin to the Selct plugins window """ if not self.loaded_p_list: self.update_scroll("[!!] No plugins loaded!") return scroll_pane = JScrollPane() scroll_pane.setPreferredSize(Dimension(200, 250)) check_frame = JPanel(GridBagLayout()) constraints = GridBagConstraints() constraints.fill = GridBagConstraints.HORIZONTAL constraints.gridy = 0 constraints.anchor = GridBagConstraints.FIRST_LINE_START for plug in self.loaded_p_list: check_frame.add(JCheckBox(plug.get_name(), plug.enabled, actionPerformed=self.update_box), constraints) constraints.gridy += 1 vport = JViewport() vport.setView(check_frame) scroll_pane.setViewport(vport) self.window.contentPane.add(scroll_pane) self.window.pack() self.window.setVisible(True) def update_box(self, event): """ Handles the check/uncheck event for the plugin's box. """ for plug in self.loaded_p_list: if plug.get_name() == event.getActionCommand(): plug.enabled = not plug.enabled if plug.enabled: self.update_scroll("[^] Enabled: %s" % event.getActionCommand()) else: self.update_scroll("[^] Disabled: %s" % event.getActionCommand()) # ITab required functions @staticmethod def getTabCaption(): """Returns the name of the Burp Suite Tab""" return "SpyDir" def getUiComponent(self): """Returns the UI component for the Burp Suite tab""" return self.tab
# http://www.jython.org/jythonbook/en/1.0/GUIApplications.html from java.awt import Component from javax.swing import JTextArea, JFrame import time frame = JFrame('Message', defaultCloseOperation = JFrame.DO_NOTHING_ON_CLOSE, size = (300, 300) ) t = JTextArea(text = 'Hello\nworld', editable = False, wrapStyleWord = True, lineWrap = True, alignmentX = Component.LEFT_ALIGNMENT, size = (300, 1) ) frame.add(t) frame.visible = True sleep(2) frame.visible = False sleep(0.5) t.text = "{}\n{}".format("Hello",time.asctime()) frame.visible = True sleep(2) frame.visible = False frame.dispose() frame = None
class Menue(object): def __init__(self, p): self.cellCounter = 1 self.olay = Overlay() self.position = p print p.getRoiPath() if p.getRoiPath() != None: # check if there is an existing overlay file and load it! p.loadRois() self.frame = JFrame("CellCropper", size=(200,200)) self.frame.setLocation(20,120) self.Panel = JPanel(GridLayout(0,1)) self.frame.add(self.Panel) #self.nameField = JTextField("p" + "_c",15) self.nameField = JTextField("p" + str(self.position.getID()) + "_c",15) self.Panel.add(self.nameField) self.cutoutButton = JButton("Cut out cell",actionPerformed=cut) self.Panel.add(self.cutoutButton) self.delOlButton = JButton("Delete Overlay",actionPerformed=delOverlay) self.Panel.add(self.delOlButton) self.saveOlButton = JButton("Save Overlay",actionPerformed=saveOverlay) self.Panel.add(self.saveOlButton) self.quitButton = JButton("Quit script",actionPerformed=quit) self.Panel.add(self.quitButton) self.frame.pack() WindowManager.addWindow(self.frame) self.show() #IJ.setTool("freehand") '''def getPosition(self, path, filename): moved to containers.position.determineID(path, filename)''' def eventtest(self, event): print "eventtest" def setTextField(self, pos): name = "p" + str(pos) + "_c" self.nameField.setText(name) def openOl(self, path, fileName): print "aaaaah" def show(self): self.frame.visible = True def close(self): if self.olay != None: yncd = YesNoCancelDialog(self.frame, "Save overlay?", "Save overlay?") #frame, title, message if yncd.yesPressed(): self.saveOverlay() WindowManager.removeWindow(self.frame) self.frame.dispose() def resetCounter(self): self.cellCounter = 0 def increaseCounter(self): self.cellCounter += 1 def setCounter(self): self.cellCounter += 1 #'get' functions def getImp(self): return self.imp def getCounter(self): return self.cellCounter def getFrame(self): return self.frame def getFilePath(self): return self.filePath def getTextField(self): return self.nameField.text def getPosition(self): return self.position # overlay functions def addOlay(self, roi): self.olay.add(roi) def getOverlay(self): return self.olay def clearOverlay(self): self.olay.clear() self.cellCounter = 1 def saveOverlay(self): self.position.saveRois()
class NewAccountGUI: def __init__(self, amgui): self.amgui = amgui self.am = amgui.acctmanager self.buildgwinfo() self.autologin = JCheckBox("Automatically Log In") self.acctname = JTextField() self.gwoptions = JPanel(doublebuffered) self.gwoptions.border = TitledBorder("Gateway Options") self.buildgwoptions("Twisted") self.mainframe = JFrame("New Account Window") self.buildpane() def buildgwinfo(self): self.gateways = { "Twisted": { "ident": JTextField(), "passwd": JPasswordField(), "host": JTextField("twistedmatrix.com"), "port": JTextField("8787"), "service": JTextField("twisted.words"), "persp": JTextField(), }, "AIM": { "ident": JTextField(), "passwd": JPasswordField(), "host": JTextField("toc.oscar.aol.com"), "port": JTextField("9898"), }, "IRC": { "ident": JTextField(), "passwd": JPasswordField(), "host": JTextField(), "port": JTextField("6667"), "channels": JTextField(), }, } self.displayorder = { "Twisted": [ ["Identity Name", "ident"], ["Password", "passwd"], ["Host", "host"], ["Port", "port"], ["Service Name", "service"], ["Perspective Name", "persp"], ], "AIM": [["Screen Name", "ident"], ["Password", "passwd"], ["Host", "host"], ["Port", "port"]], "IRC": [ ["Nickname", "ident"], ["Password", "passwd"], ["Host", "host"], ["Port", "port"], ["Channels", "channels"], ], } def buildgwoptions(self, gw): self.gwoptions.removeAll() self.gwoptions.layout = GridLayout(len(self.gateways[gw]), 2) for mapping in self.displayorder[gw]: self.gwoptions.add(JLabel(mapping[0])) self.gwoptions.add(self.gateways[gw][mapping[1]]) def buildpane(self): gw = JPanel(GridLayout(1, 2), doublebuffered) gw.add(JLabel("Gateway")) self.gwlist = JComboBox(self.gateways.keys()) # , actionPerformed=self.changegw) self.gwlist.setSelectedItem("Twisted") gw.add(self.gwlist) stdoptions = JPanel(GridLayout(2, 2), doublebuffered) stdoptions.border = TitledBorder("Standard Options") stdoptions.add(JLabel()) stdoptions.add(self.autologin) stdoptions.add(JLabel("Account Name")) stdoptions.add(self.acctname) buttons = JPanel(FlowLayout(), doublebuffered) buttons.add(JButton("OK", actionPerformed=self.addaccount)) buttons.add(JButton("Cancel", actionPerformed=self.cancel)) mainpane = self.mainframe.getContentPane() mainpane.layout = BoxLayout(mainpane, BoxLayout.Y_AXIS) mainpane.add(gw) mainpane.add(self.gwoptions) mainpane.add(stdoptions) mainpane.add(buttons) def show(self): self.mainframe.setLocation(100, 100) self.mainframe.pack() self.mainframe.show() # actionlisteners def changegw(self, ae): self.buildgwoptions(self.gwlist.getSelectedItem()) self.mainframe.pack() self.mainframe.show() def addaccount(self, ae): gwselection = self.gwlist.getSelectedItem() gw = self.gateways[gwselection] name = gw["ident"].text passwd = gw["passwd"].text host = gw["host"].text port = int(gw["port"].text) autologin = self.autologin.isSelected() acctname = self.acctname.text if gwselection == "Twisted": sname = gw["service"].text perspective = gw["persp"].text self.am.addAccount(PBAccount(acctname, autologin, name, passwd, host, port, [[stype, sname, perspective]])) elif gwselection == "AIM": self.am.addAccount(TOCAccount(acctname, autologin, name, passwd, host, port)) elif gwselection == "IRC": channels = gw["channels"].text self.am.addAccount(IRCAccount(acctname, autologin, name, passwd, host, port, channels)) self.amgui.update() print "Added new account" self.mainframe.dispose() def cancel(self, ae): print "Cancelling new account creation" self.mainframe.dispose()
class TicTacToeGame(WindowAdapter): # Tic Tac Toe game with Mario and Dizzy animated icons/music. # Computer plays with Mario and player plays with Dizzy. # game title game_title = "Tic Tac Toe: You vs Mario" # welcome status message. welcome_status = "Welcome! Please make your first move." # in-game status message. in_game_status = "Mario chases You! Hurry up!" # board 3x3 with the default color - white board = [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']] # total number of cells size = len(board) * len(board) # size of cell tile_size = 128 # status bar height status_bar_height = 50 # status bar top margin status_bar_margin_top = -15 # status bar left margin status_bar_margin_left = 10 # number of cells in a row/column cells = 3 # winner winner = None # Mario image mario = '/MARIO_128x128.gif' # Dizzy image dizzy = None # Blank blank = '/BLANK.gif' # supported musice sounds sounds = ['/DIZZY.wav', '/MARIO.wav'] # currently played sound sound = None # last chosen sound last_sound = 0 # won sound won_sound = '/WON.wav' # lose sound lose_sound = '/LOSE.wav' # tie sound tie_sound = '/TIE.wav' # action sound action_sound = '/ACTION.wav' def __init__(self, resources_directory): # Game constructor. # # Parameters: # resources_directory Directory to look for images and audio files. is_windows = platform.platform().lower().find('win') > 0 self.main_window_padding_right = 20 if is_windows else 0 self.main_window_padding_bottom = 40 if is_windows else 0 self.resources_directory = resources_directory self.button1 = JButton("", actionPerformed=self.clicked1) self.button2 = JButton("", actionPerformed=self.clicked2) self.button3 = JButton("", actionPerformed=self.clicked3) self.button4 = JButton("", actionPerformed=self.clicked4) self.button5 = JButton("", actionPerformed=self.clicked5) self.button6 = JButton("", actionPerformed=self.clicked6) self.button7 = JButton("", actionPerformed=self.clicked7) self.button8 = JButton("", actionPerformed=self.clicked8) self.button9 = JButton("", actionPerformed=self.clicked9) image_size = self.tile_size self.button1.setBounds(0 * image_size, 0 * image_size, image_size, image_size) self.button2.setBounds(1 * image_size, 0 * image_size, image_size, image_size) self.button3.setBounds(2 * image_size, 0 * image_size, image_size, image_size) self.button4.setBounds(0 * image_size, 1 * image_size, image_size, image_size) self.button5.setBounds(1 * image_size, 1 * image_size, image_size, image_size) self.button6.setBounds(2 * image_size, 1 * image_size, image_size, image_size) self.button7.setBounds(0 * image_size, 2 * image_size, image_size, image_size) self.button8.setBounds(1 * image_size, 2 * image_size, image_size, image_size) self.button9.setBounds(2 * image_size, 2 * image_size, image_size, image_size) self.buttons = [ self.button1, self.button2, self.button3, self.button4, self.button5, self.button6, self.button7, self.button8, self.button9 ] self.buttons_mapped = [[self.button1, self.button2, self.button3], [self.button4, self.button5, self.button6], [self.button7, self.button8, self.button9]] width = self.tile_size * self.cells height = width self.frame = JFrame(self.game_title, size=(width, height + self.status_bar_height)) self.frame.setLocation(200, 100) self.frame.setLayout(None) for button in self.buttons: self.frame.add(button) self.status_label = JLabel("") self.status_label.setBounds(self.status_bar_margin_left, height + self.status_bar_margin_top, width, self.status_bar_height) self.frame.add(self.status_label) self.frame.setVisible(True) self.frame.addWindowListener(self) random.shuffle(self.sounds) self.restart() # Restarts the game. def restart(self): self.dizzy = None self.dizzy = self.choosePlayer() self.winner = None self.board = [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']] for button in self.buttons: button.setIcon(ImageIcon(self.resources_directory + self.blank)) self.stop_playing_background() self.sound = self.play_sound_safe(self.sounds[self.last_sound]) self.last_sound = self.last_sound + 1 if self.last_sound >= len(self.sounds): self.last_sound = 0 self.status_label.setText(self.welcome_status) # Stops playing any background music, if any playing now. def stop_playing_background(self): if self.sound != None: self.sound.stopPlaying() self.sound = None def set_dizzy(self, button): # Draws Dizzy in a given button, sets game status to "Playing" and # plays action sound. # # Parameters: # button to set Dizzy icon to. button.setIcon(ImageIcon(self.resources_directory + self.dizzy)) self.status_label.setText(self.in_game_status) self.play_sound_safe(self.action_sound) def set_mario(self, button): # Draws Mario in a given button. # # Parameters: # button to set Mario icon to. button.setIcon(ImageIcon(self.resources_directory + self.mario)) def clicked1(self, event): # Event listener method for the button of the game at 0x0. # # Parameters: # event Click event. if self.board[0][0] != ' ': return self.board[0][0] = 'X' self.set_dizzy(self.button1) self.computer_move() def clicked2(self, event): # Event listener method for the button of the game at 0x1. # # Parameters: # event Click event. if self.board[0][1] != ' ': return self.board[0][1] = 'X' self.set_dizzy(self.button2) self.computer_move() def clicked3(self, event): # Event listener method for the button of the game at 0x2. # # Parameters: # event Click event. if self.board[0][2] != ' ': return self.board[0][2] = 'X' self.set_dizzy(self.button3) self.computer_move() def clicked4(self, event): # Event listener method for the button of the game at 1x0. # # Parameters: # event Click event. if self.board[1][0] != ' ': return self.board[1][0] = 'X' self.set_dizzy(self.button4) self.computer_move() def clicked5(self, event): # Event listener method for the button of the game at 1x1. # # Parameters: # event Click event. if self.board[1][1] != ' ': return self.board[1][1] = 'X' self.set_dizzy(self.button5) self.computer_move() def clicked6(self, event): # Event listener method for the button of the game at 1x2. # # Parameters: # event Click event. if self.board[1][2] != ' ': return self.board[1][2] = 'X' self.set_dizzy(self.button6) self.computer_move() def clicked7(self, event): # Event listener method for the button of the game at 2x0. # # Parameters: # event Click event. if self.board[2][0] != ' ': return self.board[2][0] = 'X' self.set_dizzy(self.button7) self.computer_move() def clicked8(self, event): # Event listener method for the button of the game at 2x1. # Parameters: # event Click event. if self.board[2][1] != ' ': return self.board[2][1] = 'X' self.set_dizzy(self.button8) self.computer_move() def clicked9(self, event): # Event listener method for the button of the game at 2x2. # # Parameters: # event Click event. if self.board[2][2] != ' ': return self.board[2][2] = 'X' self.set_dizzy(self.button9) self.computer_move() # Makes the next move on the board on behalf of the computer. def computer_move(self): # first move optimization - always start in the middle if possible if self.board[1][1] == ' ': self.board[1][1] = '0' self.set_mario(self.buttons_mapped[1][1]) self.test_state() return while self.has_empty_cell(): y = random.randint(0, self.cells - 1) x = random.randint(0, self.cells - 1) if self.board[y][x] == ' ': self.board[y][x] = '0' self.set_mario(self.buttons_mapped[y][x]) break self.test_state() def test_state(self): # Tests the board for a winning state. # If there is a winner then stops currently playing # background sound, creates winning label, plays result # sound and notifies/asks the user about continuation. if self.is_any_line_filled('X'): self.winner = self.dizzy # dizzy elif self.is_any_line_filled('0'): self.winner = self.mario # mario elif not self.has_empty_cell(): self.winner = self.blank # tie if self.winner: label = 'Tie.' self.stop_playing_background() if self.winner == self.mario: label = 'You lose!' self.play_sound_safe(self.lose_sound) elif self.winner == self.dizzy: label = 'You won!' self.play_sound_safe(self.won_sound) else: self.play_sound_safe(self.tie_sound) self.notify_and_ask_about_continuation(label) def notify_and_ask_about_continuation(self, label): # Shows modal window with the result of the game and asks the use whether they want to # continue the game. # If user answers "Y" or "y" restarts the game. # If user answers "N" or "n" closes the game window and frees the resources. # Parameters: # label Game result label. answer = None self.status_label.setText(label) while True: answer = str( requestString(label + "\r\n" + "Do you want to play again? (Y/N)")) if answer.lower() == "y": self.restart() break elif answer.lower() == "n": self.windowClosing(None) break def is_any_line_filled(self, character): # Checks the winning condition for the given character 'X' or '0'. # # Returns: # Whether the given character 'X' or '0' has a winning line filled. is_row = self.is_row_filled(character) is_col = self.is_col_filled(character) is_d1 = self.is_diag_filled1(character) is_d2 = self.is_diag_filled2(character) return is_row or is_col or is_d1 or is_d2 def has_empty_cell(self): #Checks if the game board contains an empty cell for the next move. # #Returns: # Whether there is an empty cell on the board. for row in range(len(self.board)): for col in range(len(self.board)): if self.board[row][col] == ' ': return True return False def is_row_filled(self, color): # Check row win condition. # # Parameters: # color (string) - color to check if the whole row of the same color # Returns: # True (boolean) - if the whole row of the same color # False (boolean) - if the row is not of the same color for row in range(len(self.board)): count = 0 for col in range(len(self.board)): if self.board[row][col] == color: count = count + 1 if count == self.cells: return True return False def is_col_filled(self, color): #Check column win condition. # # Parameters: # color (string) - color to check if the whole column of the same color # Returns: # True (boolean) - if the whole column of the same color # False (boolean) - if the column is not of the same color for col in range(len(self.board)): count = 0 for row in range(len(self.board)): if self.board[row][col] == color: count = count + 1 if count == self.cells: return True return False def is_diag_filled1(self, color): # Checks first diagonal win condition. # # Parameters: # color (string) - color to check if the whole diagonal of the same color # Returns: # True (boolean) - if the whole diagonal of the same color # False (boolean) - if the diagonal is not of the same color count = 0 for idx in range(len(self.board)): if self.board[idx][idx] == color: count = count + 1 return count == self.cells def is_diag_filled2(self, color): # Checks second diagonal win condition. # # Parameters: # color (string) - color to check if the whole diagonal of the same color # Returns: # True (boolean) - if the whole diagonal of the same color # False (boolean) - if the diagonal is not of the same color count = 0 for idx in range(len(self.board)): if self.board[idx][self.cells - 1 - idx] == color: count = count + 1 return count == self.cells def play_sound_safe(self, sound): # Method tries to play given sound catching possible exceptions. # For example, if the sound wasn't found in resource directory # # Parameters: # sound string with a file of a sound with leading slash '/'. # Returns: # Created Sound object fromo makeSound. snd = None try: snd = makeSound(self.resources_directory + sound) play(snd) except: showError("Error while playing sound " + str(sound) + ".") return snd def windowClosing(self, event): # Method is invoked when a user closes game window or finishes playing. # It is the implementation of WindowAdapter interface. # # Parameters: final event from Swing/AWT self.stop_playing_background() self.buttons = [] self.buttons_mapped = [] self.button1 = None self.button2 = None self.button3 = None self.button4 = None self.button5 = None self.button6 = None self.button7 = None self.button8 = None self.button9 = None self.status_label = None self.frame.getContentPane().removeAll() self.frame.dispose() self.frame = None def choosePlayer(self): while true: select = requestString( "You are against Mario. Choose Your Character: penguin chrome fox fish bird charizard sonic " ) selection = select.lower() if selection == "penguin": return rpenguin break if selection == "chrome": return rchrome break if selection == "fox": return rfox break if selection == "fish": return rfish break if selection == "bird": return rbird break if selection == "charizard": return rcharizard break if selection == "sonic": return rsonic break
class BurpExtender(IBurpExtender, ITab, IScannerCheck, IScannerInsertionPoint, IContextMenuFactory): # definitions EXTENSION_NAME="IssueCreator" tmpl = dict() tmpl['XSS'] = dict() tmpl['XSS']['name'] = 'Cross-Site Scripting (reflected)' tmpl['XSS']['idetail'] = 'It is possible to inject arbitrary JavaScript into the application\'s response' tmpl['XSS']['ibackground'] = '''Reflected cross-site scripting vulnerabilities arise when data is copied from a request and echoed into the application's immediate response in an unsafe way. An attacker can use the vulnerability to construct a request which, if issued by another application user, will cause JavaScript code supplied by the attacker to execute within the user's browser in the context of that user's session with the application. The attacker-supplied code can perform a wide variety of actions, such as stealing the victim's session token or login credentials, performing arbitrary actions on the victim's behalf, and logging their keystrokes. Users can be induced to issue the attacker's crafted request in various ways. For example, the attacker can send a victim a link containing a malicious URL in an email or instant message. They can submit the link to popular web sites that allow content authoring, for example in blog comments. And they can create an innocuous looking web site which causes anyone viewing it to make arbitrary cross-domain requests to the vulnerable application (using either the GET or the POST method). The security impact of cross-site scripting vulnerabilities is dependent upon the nature of the vulnerable application, the kinds of data and functionality which it contains, and the other applications which belong to the same domain and organization. If the application is used only to display non-sensitive public content, with no authentication or access control functionality, then a cross-site scripting flaw may be considered low risk. However, if the same application resides on a domain which can access cookies for other more security-critical applications, then the vulnerability could be used to attack those other applications, and so may be considered high risk. Similarly, if the organization which owns the application is a likely target for phishing attacks, then the vulnerability could be leveraged to lend credibility to such attacks, by injecting Trojan functionality into the vulnerable application, and exploiting users' trust in the organization in order to capture credentials for other applications which it owns. In many kinds of application, such as those providing online banking functionality, cross-site scripting should always be considered high risk. ''' tmpl['XSS']['rdetail'] = ''''Input should be validated as strictly as possible on arrival, given the kind of content which it is expected to contain. For example, personal names should consist of alphabetical and a small range of typographical characters, and be relatively short; a year of birth should consist of exactly four numerals; email addresses should match a well-defined regular expression. Input which fails the validation should be rejected, not sanitized. User input should be HTML-encoded at any point where it is copied into application responses. All HTML metacharacters, including < > " ' and =, should be replaced with the corresponding HTML entities (< > etc). In cases where the application's functionality allows users to author content using a restricted subset of HTML tags and attributes (for example, blog comments which allow limited formatting and linking), it is necessary to parse the supplied HTML to validate that it does not use any dangerous syntax; this is a non-trivial task. ''' tmpl['XSS']['rbackground'] = 'do not trust user input!' tmpl['SQLi'] = dict() tmpl['SQLi']['name'] = 'SQL Injection' tmpl['SQLi']['idetail'] = 'Input parameter appears to be vulnerable to SQL injection attacks.' tmpl['SQLi']['ibackground'] = '''SQL injection vulnerabilities arise when user-controllable data is incorporated into database SQL queries in an unsafe manner. An attacker can supply crafted input to break out of the data context in which their input appears and interfere with the structure of the surrounding query. Various attacks can be delivered via SQL injection, including reading or modifying critical application data, interfering with application logic, escalating privileges within the database and executing operating system commands. ''' tmpl['SQLi']['rdetail'] = '''The most effective way to prevent SQL injection attacks is to use parameterized queries (also known as prepared statements) for all database access. This method uses two steps to incorporate potentially tainted data into SQL queries: first, the application specifies the structure of the query, leaving placeholders for each item of user input; second, the application specifies the contents of each placeholder. Because the structure of the query has already defined in the first step, it is not possible for malformed data in the second step to interfere with the query structure. You should review the documentation for your database and application platform to determine the appropriate APIs which you can use to perform parameterized queries. It is strongly recommended that you parameterize every variable data item that is incorporated into database queries, even if it is not obviously tainted, to prevent oversights occurring and avoid vulnerabilities being introduced by changes elsewhere within the code base of the application. ''' tmpl['SQLi']['rbackground'] = 'SQL Injection background' tmpl['Insecure-Cookie'] = dict() tmpl['Insecure-Cookie']['name'] = 'Cookie Was Set Without Secure Flag' tmpl['Insecure-Cookie']['idetail'] = 'Application has set a secure cookie without the secure attribute' tmpl['Insecure-Cookie']['ibackground'] = 'Client will send this cookie over the clear via http. This could be eavesdropped on.' tmpl['Insecure-Cookie']['rdetail'] = 'The application should set all cookies that are session related or sensitive in nature with the secure attribute.' tmpl['Insecure-Cookie']['rbackground'] = '...' tmpl['Your-Item'] = dict() tmpl['Your-Item']['name'] = 'My issue name' tmpl['Your-Item']['idetail'] = 'My issue detail' tmpl['Your-Item']['ibackground'] = 'the issue background here' tmpl['Your-Item']['rdetail'] = '''the remediation detail. i'll put this in triple quotes. because. ''' tmpl['Your-Item']['rbackground'] = 'this is remediation background information for my issue' def registerExtenderCallbacks(self, callbacks): # keep a reference to our callbacks object self._callbacks = callbacks # obtain an extension helpers object self._helpers = callbacks.getHelpers() # define stdout writer self._stdout = PrintWriter(callbacks.getStdout(), True) self._stdout.println(self.EXTENSION_NAME + ' by @luxcupitor') self._stdout.println('================================') self._stdout.println('') self._stdout.println('TIP: right click on items in proxy or repeater tab') self._stdout.println('and select "Add as Issue to Scanner".') self._stdout.println('') # set our extension name callbacks.setExtensionName(self.EXTENSION_NAME) # setup a context menu for the proxy tab. needs createMenuItems callbacks.registerContextMenuFactory(self) return def createMenuItems(self, caller): '''caller is the burpsuite context that invoked the menu''' menu = [] #Proxy tab is context 6/repeater request is 0/repeater response is 3 idx = caller.getInvocationContext() if idx == 6 or idx == 0 or idx == 3: menu.append(JMenuItem("Add as Issue to Scanner", None, actionPerformed=lambda x, c=caller: self.launchGui(c))) return menu if menu else None def getMatches(self, response, match): '''This finds our pattern match in the request/response and returns an int array''' start = 0 count = 0 matches = [array('i')] while start < len(response): start=self._helpers.indexOf(response, match, True, start, len(response)) if start == -1: break try: matches[count] except: matches.append(array('i')) matches[count].append(start) matches[count].append(start+len(match)) start += len(match) count += 1 return matches def logScanIssue(self, baseRequestResponse): '''This is redundant (mostly) of the doPassiveScan function''' reqPATTERN=self.reqPattern.text resPATTERN=self.resPattern.text ISSUE_NAME=self.issueNameField.text ISSUE_DETAIL=self.issueDetailField.text ISSUE_BACKGROUND=self.issueBackgroundField.text REMEDIATION_BACKGROUND=self.remediationBackgroundField.text REMEDIATION_DETAIL=self.remediationDetailField.text if self.radioBtnSevHigh.isSelected(): SEVERITY="High" elif self.radioBtnSevMedium.isSelected(): SEVERITY="Medium" else: SEVERITY="Low" CONFIDENCE="Certain" self._stdout = PrintWriter(self._callbacks.getStdout(), True) self._stdout.println('logScanIssue has been called') self._stdout.println('[-] ISSUE_NAME: ' + ISSUE_NAME) self._stdout.println('[-] ISSUE_DETAIL: ' + ISSUE_DETAIL) self._stdout.println('[-] ISSUE_BACKGROUND: ' + ISSUE_BACKGROUND) self._stdout.println('[-] REMEDIATION_DETAIL: ' + REMEDIATION_DETAIL) self._stdout.println('[-] REMEDIATION_BACKGROUND: ' + REMEDIATION_BACKGROUND) self._stdout.println('[-] SEVERITY: ' + SEVERITY) self._stdout.println('[-] CONFIDENCE: ' + CONFIDENCE) match = False if reqPATTERN == "": reqmatch = None else: reqmatch = self.getMatches(baseRequestResponse.getRequest(), reqPATTERN) match = True if resPATTERN == "": resmatch = None else: resmatch = self.getMatches(baseRequestResponse.getResponse(), resPATTERN) match = True if match: httpmsgs = [self._callbacks.applyMarkers(baseRequestResponse,reqmatch,resmatch)] issue=ScanIssue(baseRequestResponse.getHttpService(), self._helpers.analyzeRequest(baseRequestResponse).getUrl(), httpmsgs, ISSUE_NAME, ISSUE_DETAIL, SEVERITY, CONFIDENCE, ISSUE_BACKGROUND, REMEDIATION_DETAIL, REMEDIATION_BACKGROUND) self._callbacks.addScanIssue(issue) self.closeUI(None) return def launchGui(self, caller): self._stdout = PrintWriter(self._callbacks.getStdout(), True) self._stdout.println('Launching gui') callMessage = caller.getSelectedMessages() self.msg1 = callMessage[0] #setup frame self.frame = JFrame('Create Issue', windowClosing=self.closeUI) Border = BorderFactory.createLineBorder(Color.BLACK) #create split panel to add issue panel and template panel self.splitPane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT) self.frame.add(self.splitPane) #panel setup and add to splitPane self.issuePanel = JPanel(GridLayout(0,2)) self.splitPane.setLeftComponent(self.issuePanel) #setup issue name text fields to add to panel self.issueNameField = JTextField('',15) self.issueNameLabel = JLabel("IssueName:", SwingConstants.CENTER) self.issuePanel.add(self.issueNameLabel) self.issuePanel.add(self.issueNameField) #add issue detail text area self.issueDetailField = JTextArea() self.issueDetailField.editable = True self.issueDetailField.wrapStyleWord = True self.issueDetailField.lineWrap = True self.issueDetailField.alignmentX = Component.LEFT_ALIGNMENT self.issueDetailField.size = (200, 20) self.issueDetailField.setBorder(Border) self.idfSp = JScrollPane() self.idfSp.getViewport().setView((self.issueDetailField)) self.issuePanel.add(JLabel("Issue Detail:", SwingConstants.CENTER)) self.issuePanel.add(self.idfSp) self.issueBackgroundField= JTextArea() self.issueBackgroundField.editable = True self.issueBackgroundField.wrapStyleWord = True self.issueBackgroundField.lineWrap = True self.issueBackgroundField.alignmentX = Component.LEFT_ALIGNMENT self.issueBackgroundField.size = (200, 20) self.issueBackgroundField.setBorder(Border) self.ibfSp = JScrollPane() self.ibfSp.getViewport().setView((self.issueBackgroundField)) self.issuePanel.add(JLabel("Issue Background:", SwingConstants.CENTER)) self.issuePanel.add(self.ibfSp) #add remediation detail text area self.remediationDetailField = JTextArea() self.remediationDetailField.editable = True self.remediationDetailField.wrapStyleWord = True self.remediationDetailField.lineWrap = True self.remediationDetailField.alignmentX = Component.LEFT_ALIGNMENT self.remediationDetailField.size = (200, 20) self.remediationDetailField.setBorder(Border) self.rdfSp = JScrollPane() self.rdfSp.getViewport().setView((self.remediationDetailField)) self.issuePanel.add(JLabel("Remediation Detail:", SwingConstants.CENTER)) self.issuePanel.add(self.rdfSp) self.remediationBackgroundField= JTextArea() self.remediationBackgroundField.editable = True self.remediationBackgroundField.wrapStyleWord = True self.remediationBackgroundField.lineWrap = True self.remediationBackgroundField.alignmentX = Component.LEFT_ALIGNMENT self.remediationBackgroundField.size = (200, 20) self.remediationBackgroundField.setBorder(Border) self.rbfSp = JScrollPane() self.rbfSp.getViewport().setView((self.remediationBackgroundField)) self.issuePanel.add(JLabel("Remediation Background:", SwingConstants.CENTER)) self.issuePanel.add(self.rbfSp) #add radio buttons for severity self.radioBtnSevHigh = JRadioButton('High', actionPerformed=None) self.radioBtnSevMedium = JRadioButton('Medium', actionPerformed=None) self.radioBtnSevLow = JRadioButton('Low', actionPerformed=None) severityButtonGroup = ButtonGroup() severityButtonGroup.add(self.radioBtnSevHigh) severityButtonGroup.add(self.radioBtnSevMedium) severityButtonGroup.add(self.radioBtnSevLow) self.radioBtnSevHigh.setSelected(True) self.issuePanel.add(JLabel("Severity:", SwingConstants.CENTER)) self.issuePanel.add(self.radioBtnSevHigh) self.issuePanel.add(self.radioBtnSevMedium) self.issuePanel.add(self.radioBtnSevLow) self.reqPattern = JTextField('',15) self.issuePanel.add(JLabel("Mark Pattern in Request:", SwingConstants.CENTER)) self.issuePanel.add(self.reqPattern) self.resPattern = JTextField('',15) self.issuePanel.add(JLabel("Mark Pattern in Response:", SwingConstants.CENTER)) self.issuePanel.add(self.resPattern) #add a button self.issueButton = JButton('Add!', actionPerformed=lambda x, m=self.msg1: self.logScanIssue(m)) self.issuePanel.add(self.issueButton) #template panel setup self.templatePanel = JPanel(GridLayout(1,2)) self.splitPane.setRightComponent(self.templatePanel) #add a list of templates self.templatePanel.add(JLabel("Select from Templates", SwingConstants.CENTER)) self.templateData = tuple(self.tmpl.keys()) self.templateList = JList(self.templateData) self.templateScrollPane = JScrollPane() #self.templateScrollPane.setPreferredSize(Dimension(100,125)) self.templateScrollPane.getViewport().setView((self.templateList)) self.templatePanel.add(self.templateScrollPane) self.templateButton = JButton('Apply', actionPerformed=self.applyTemplate) self.templatePanel.add(self.templateButton) #pack up the frame and display it self.frame.pack() self.show() def applyTemplate(self, event): selected = self.templateList.selectedIndex if selected >= 0: self.issueNameField.text = self.tmpl[self.templateData[selected]]['name'] self.issueDetailField.text = self.tmpl[self.templateData[selected]]['idetail'] self.issueBackgroundField.text = self.tmpl[self.templateData[selected]]['ibackground'] self.remediationDetailField.text = self.tmpl[self.templateData[selected]]['rdetail'] self.remediationBackgroundField.text = self.tmpl[self.templateData[selected]]['rbackground'] def show(self): self.frame.visible = True def closeUI(self, event): self.frame.setVisible(False) self.frame.dispose()
class MandersPlugin(ImageListener, WindowAdapter): def __init__(self): self.imp = None self.preview = None self.createMainWindow() self.cells = None self.files = [] self.results = ResultsTable() ImagePlus.addImageListener(self) self.selectInputDir() self.selectOutputDir() self.pairs = [] self.methods = [] self.processNextFile() def selectInputDir(self): inputDialog = DirectoryChooser("Please select a directory contaning your images") inputDir = inputDialog.getDirectory() for imageFile in os.listdir(inputDir): self.files.append(inputDir + imageFile) def selectOutputDir(self): outputDialog = DirectoryChooser("Please select a directory to save your results") self.outputDir = outputDialog.getDirectory() def closeImage(self): if self.imp is not None: self.imp.close() self.imp = None if self.preview is not None: self.preview.close() self.preview = None def openImage(self, imageFile): try: images = BF.openImagePlus(imageFile) self.imp = images[0] except UnknownFormatException: return None if self.imp.getNChannels() < 2: IJ.error("Bad image format", "Image must contain at lease 2 channels!") return None if not self.pairs or \ not self.methods: self.getOptionsDialog(self.imp) title = self.imp.title self.imp.title = title[:title.rfind('.')] return self.imp def getOptionsDialog(self, imp): thr_methods = ["None", "Default", "Huang", "Intermodes", "IsoData", "Li", "MaxEntropy","Mean", "MinError(I)", "Minimum", "Moments", "Otsu", "Percentile", "RenyiEntropy", "Shanbhag" , "Triangle", "Yen"] gd = GenericDialog("Please select channels to collocalize") for i in range(1, imp.getNChannels() + 1): gd.addChoice("Threshold method for channel %i" % i, thr_methods, "None") gd.showDialog() if gd.wasCanceled(): self.exit() channels = [] for i in range(1, imp.getNChannels() + 1): method = gd.getNextChoice() self.methods.append(method) if method != "None": channels.append(i) for x in channels: for y in channels: if x < y: self.pairs.append((x, y)) def processNextFile(self): if self.files: imageFile = self.files.pop(0) return self.processFile(imageFile) else: return False def processFile(self, imageFile): imp = self.openImage(imageFile) if imp is not None: cell = Cell(imp.NSlices, 1) self.cells = DelegateListModel([]) self.cells.append(cell) self.showMainWindow(self.cells) if self.checkbox3D.isSelected(): self.displayImage(imp) else: self.displayImage(imp, False) self.preview = self.previewImage(imp) self.displayImage(self.preview) return True else: return self.processNextFile() def displayImage(self, imp, show = True): imp.setDisplayMode(IJ.COMPOSITE) enhancer = ContrastEnhancer() enhancer.setUseStackHistogram(True) splitter = ChannelSplitter() for c in range(1, imp.getNChannels() + 1): imp.c = c enhancer.stretchHistogram(imp, 0.35) if show: imp.show() def previewImage(self, imp): roi = imp.getRoi() splitter = ChannelSplitter() channels = [] for c in range(1, imp.getNChannels() + 1): channel = ImagePlus("Channel %i" % c, splitter.getChannel(imp, c)) projector = ZProjector(channel) projector.setMethod(ZProjector.MAX_METHOD) projector.doProjection() channels.append(projector.getProjection()) image = RGBStackMerge.mergeChannels(channels, False) image.title = imp.title + " MAX Intensity" image.luts = imp.luts imp.setRoi(roi) return image def getCroppedChannels(self, imp, cell): splitter = ChannelSplitter() imp.setRoi(None) if cell.mode3D: cropRoi = cell.getCropRoi() else: cropRoi = cell.roi if cropRoi is None: return None crop = cropRoi.getBounds() channels = [] for c in range(1, imp.getNChannels() + 1): slices = ImageStack(crop.width, crop.height) channel = splitter.getChannel(imp, c) for z in range(1, channel.getSize() + 1): zslice = channel.getProcessor(z) zslice.setRoi(cropRoi) nslice = zslice.crop() if cell.mode3D: oroi = cell.slices[z - 1].roi else: oroi = cell.roi if oroi is not None: roi = oroi.clone() bounds = roi.getBounds() roi.setLocation(bounds.x - crop.x, bounds.y - crop.y) nslice.setColor(Color.black) nslice.fillOutside(roi) slices.addSlice(nslice) channels.append(ImagePlus("Channel %i" % c, slices)) return channels def getThreshold(self, imp, method): thresholder = Auto_Threshold() duplicator = Duplicator() tmp = duplicator.run(imp) return thresholder.exec(tmp, method, False, False, True, False, False, True) def getContainer(self, impA, impB): imgA = ImagePlusAdapter.wrap(impA) imgB = ImagePlusAdapter.wrap(impB) return DataContainer(imgA, imgB, 1, 1, "imageA", "imageB") def getManders(self, imp, cell): ### Crop channels according to cell mask channels = self.getCroppedChannels(imp, cell) if channels is None: return None ### Calculate channel thresholds thrs = [] thrimps = [] for c, method in enumerate(self.methods): if method != "None": thr, thrimp = self.getThreshold(channels[c], method) else: thr, thrimp = None, None thrs.append(thr) thrimps.append(thrimp) ### Calculate manders colocalization manders = MandersColocalization() raws = [] thrds = [] for chA, chB in self.pairs: container = self.getContainer(channels[chA - 1], channels[chB - 1]) img1 = container.getSourceImage1() img2 = container.getSourceImage2() mask = container.getMask() cursor = TwinCursor(img1.randomAccess(), img2.randomAccess(), Views.iterable(mask).localizingCursor()) rtype = img1.randomAccess().get().createVariable() raw = manders.calculateMandersCorrelation(cursor, rtype) rthr1 = rtype.copy() rthr2 = rtype.copy() rthr1.set(thrs[chA - 1]) rthr2.set(thrs[chB - 1]) cursor.reset() thrd = manders.calculateMandersCorrelation(cursor, rthr1, rthr2, ThresholdMode.Above) raws.append(raw) thrds.append(thrd) return (channels, thrimps, thrs, raws, thrds) def saveMultichannelImage(self, title, channels, luts): tmp = RGBStackMerge.mergeChannels(channels, False) tmp.luts = luts saver = FileSaver(tmp) saver.saveAsTiffStack(self.outputDir + title + ".tif") tmp.close() def createMainWindow(self): self.frame = JFrame('Select cells and ROIs', defaultCloseOperation = JFrame.DISPOSE_ON_CLOSE ) self.frame.setLayout(GridBagLayout()) self.frame.addWindowListener(self) self.frame.add(JLabel("Cells"), GridBagConstraints(0, 0, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, Insets(5, 2, 2, 0), 0, 0 )) self.cellList = JList(DelegateListModel([]), selectionMode = ListSelectionModel.SINGLE_SELECTION, cellRenderer = MyRenderer(), selectedIndex = 0, valueChanged = self.selectCell ) self.frame.add(JScrollPane(self.cellList), GridBagConstraints(0, 1, 1, 5, .5, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, Insets(0, 2, 2, 0), 0, 0 )) self.frame.add(JButton('Add cell', actionPerformed = self.addCell), GridBagConstraints(1, 2, 1, 2, 0, .25, GridBagConstraints.CENTER, GridBagConstraints.NONE, Insets(0, 0, 0, 0), 0, 0 )) self.frame.add(JButton('Remove cell', actionPerformed = self.removeCell), GridBagConstraints(1, 4, 1, 2, 0, .25, GridBagConstraints.CENTER, GridBagConstraints.NONE, Insets(0, 5, 0, 5), 0, 0 )) self.frame.add(JLabel("Slices"), GridBagConstraints(0, 6, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, Insets(5, 2, 2, 0), 0, 0 )) self.sliceList = JList(DelegateListModel([]), selectionMode = ListSelectionModel.SINGLE_SELECTION, cellRenderer = MyRenderer(), selectedIndex = 0, valueChanged = self.selectSlice ) self.frame.add(JScrollPane(self.sliceList), GridBagConstraints(0, 7, 1, 5, .5, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, Insets(0, 2, 2, 0), 0, 0 )) self.frame.add(JButton('Update ROI', actionPerformed = self.updateSlice), GridBagConstraints(1, 8, 1, 2, 0, .25, GridBagConstraints.CENTER, GridBagConstraints.NONE, Insets(0, 0, 0, 0), 0, 0 )) self.frame.add(JButton('Done', actionPerformed = self.doneSelecting), GridBagConstraints(1, 10, 1, 2, 0, .25, GridBagConstraints.CENTER, GridBagConstraints.NONE, Insets(0, 0, 0, 0), 0, 0 )) self.checkbox3D = JCheckBox('3D selection mode', True, actionPerformed=self.toggle3D) self.frame.add(self.checkbox3D, GridBagConstraints(0, 13, 2, 1, 0, 1, GridBagConstraints.WEST, GridBagConstraints.NONE, Insets(0, 0, 0, 0), 0, 0 )) def showMainWindow(self, cells = None): if cells is not None: self.cellList.model = cells if cells: self.cellList.selectedIndex = 0 self.frame.pack() self.frame.visible = True def hideMainWindow(self): self.frame.visible = False def closeMainWindow(self): self.frame.dispose() def toggle3D(self, event): mode3D = self.checkbox3D.isSelected() if mode3D: self.sliceList.enabled = True if self.imp is not None: self.imp.show() if self.preview is not None: self.preview.hide() else: self.sliceList.enabled = False if self.preview is None: self.preview = self.previewImage(self.imp) self.displayImage(self.preview) else: self.preview.show() if self.imp is not None: self.imp.hide() selectedCell = self.cellList.selectedIndex if selectedCell >= 0: cell = self.cells[selectedCell] self.sliceList.model = cell.slices self.sliceList.selectedIndex = 0 def addCell(self, event): size = len(self.cells) if (size > 0): last = self.cells[size - 1] n = last.n + 1 else: n = 1 self.cells.append(Cell(self.imp.NSlices, n)) self.cellList.selectedIndex = size def removeCell(self, event): selected = self.cellList.selectedIndex if selected >= 0: self.cells.remove(self.cells[selected]) if (selected >= 1): self.cellList.selectedIndex = selected - 1 else: self.cellList.selectedIndex = 0 def selectCell(self, event): selected = self.cellList.selectedIndex if selected >= 0: cell = self.cells[selected] self.sliceList.model = cell.slices self.sliceList.selectedIndex = 0 else: self.sliceList.model = DelegateListModel([]) if self.preview is not None: self.preview.setRoi(cell.roi) def selectSlice(self, event): selectedCell = self.cellList.selectedIndex selectedSlice = self.sliceList.selectedIndex if selectedCell >= 0 and selectedSlice >= 0: cell = self.cells[selectedCell] image = self.imp mode3D = self.checkbox3D.isSelected() if image is not None and cell is not None and mode3D: roi = cell.slices[selectedSlice].roi if (image.z - 1 != selectedSlice): image.z = selectedSlice + 1 image.setRoi(roi, True) if self.preview is not None and not mode3D: self.preview.setRoi(cell.roi, True) def updateSlice(self, event): if self.checkbox3D.isSelected(): self.updateSlice3D(self.imp) else: self.updateSlice2D(self.preview) def updateSlice3D(self, imp): selectedCell = self.cellList.selectedIndex selectedSlice = self.sliceList.selectedIndex if selectedCell >= 0 and selectedSlice >= 0 and imp is not None: cell = self.cells[selectedCell] impRoi = imp.getRoi() if cell is not None and impRoi is not None: index = selectedSlice + 1 roi = ShapeRoi(impRoi, position = index) cell.mode3D = True cell.name = "Cell %i (3D)" % cell.n cell.slices[selectedSlice].roi = roi if (index + 1 <= len(cell.slices)): imp.z = index + 1 self.cellList.repaint(self.cellList.getCellBounds(selectedCell, selectedCell)) self.sliceList.repaint(self.sliceList.getCellBounds(selectedSlice, selectedSlice)) def updateSlice2D(self, imp): selectedCell = self.cellList.selectedIndex if selectedCell >= 0 and imp is not None: cell = self.cells[selectedCell] impRoi = imp.getRoi() if cell is not None and impRoi is not None: roi = ShapeRoi(impRoi, position = 1) cell.mode3D = False cell.name = "Cell %i (2D)" % cell.n cell.roi = roi self.cellList.repaint(self.cellList.getCellBounds(selectedCell, selectedCell)) def imageOpened(self, imp): pass def imageClosed(self, imp): pass def imageUpdated(self, imp): if self.checkbox3D.isSelected(): if imp is not None: selectedCell = self.cellList.selectedIndex selectedSlice = imp.z - 1 if imp == self.imp and selectedSlice != self.sliceList.selectedIndex: self.sliceList.selectedIndex = selectedSlice def doneSelecting(self, event): oluts = self.imp.luts luts = [] channels = [] for c, method in enumerate(self.methods): if method != "None": luts.append(oluts[c]) channels.append(c) for cell in self.cells: manders = self.getManders(self.imp, cell) if manders is not None: chimps, thrimps, thrs, raws, thrds = manders index = self.cells.index(cell) + 1 title = "Cell_%i-" % index + self.imp.title self.saveMultichannelImage(title, chimps, oluts) title = "Cell_%i_thrd-" % index + self.imp.title self.saveMultichannelImage(title, thrimps, luts) self.results.incrementCounter() row = self.results.getCounter() - 1 for i, thr in enumerate(thrs): if thr is not None: self.results.setValue("Threshold %i" % (i + 1), row, int(thr)) for i, pair in enumerate(self.pairs): self.results.setValue("%i-%i M1 raw" % pair, row, float(raws[i].m1)) self.results.setValue("%i-%i M2 raw" % pair, row, float(raws[i].m2)) self.results.setValue("%i-%i M1 thrd" % pair, row, float(thrds[i].m1)) self.results.setValue("%i-%i M2 thrd" % pair, row, float(thrds[i].m2)) self.closeImage() if not self.processNextFile(): print "All done - happy analysis!" self.results.show("Manders collocalization results") self.exit() def windowClosing(self, e): print "Closing plugin - BYE!!!" self.exit() def exit(self): ImagePlus.removeImageListener(self) self.closeImage() self.closeMainWindow()
class correctionTable(TextPanel): """A class that displays an imagePlus and a resultstable. Resultstable and imp are linked in such a way that click on a table row shows the imps respective timeframe.""" def __init__(self, cell, mF, title="Results"): # add mF? # Call constructor of superclass TextPanel.__init__(self) # pass menue for setting save active/inactive self.cell = cell self.mF = mF # Create a window to show the content in self.window = JFrame() self.window.add(self) self.window.setTitle(title) # Add event listeners for keyboard and mouse responsiveness self.addKeyListener(ListenToKey()) self.addMouseListener(ListenToMouse()) # TODO: unpacking info out of cell object should be done in cell object itself and accessible e. g. via getData() self.imp = self.openImp(self.cell.getMeasTifPath()) csvFile = open(self.cell.getCsvPath()) lines = csvFile.readlines() heads = lines.pop(0) self.setColumnHeadings("Frame\tDistance\tAnaphase") self.XYZtable = [] for line in lines: # load file lines in textPanel. frame, timepoint, dist, ch0x, ch0y, ch0z, ch0vol, ch1x, ch1y, ch1z, ch1vol = line.split(",") self.append(frame + "\t" + dist + "\t" ) self.XYZtable.append((ch0x, ch0y, ch0z, ch0vol, ch1x, ch1y, ch1z, ch1vol)) self.setSelection(0,0) # int startline, int endline self.changeFrame() self.mF.setSaveInactive() self.requestFocus() self.window.setSize(Dimension(220, 600)) x = int(self.imp.getWindow().getLocation().getX()) + int(self.imp.getWindow().getWidth()) + 10 self.window.setLocation(x, int(self.imp.getWindow().getLocation().getY()) ) self.window.show() # Methods implementing KeyAdapter and MouseListener #... no multiple inheritance for Java classes? # - - - - Event driven methods - - - - # ------------------------------------ def changeFrame(self): if self.getSelectionEnd() >= 0: frame, dist, AOCol = self.getLine(self.getSelectionEnd()).split("\t") self.imp.setSlice(int(frame)+1) def setAnaphase(self): frame, Distance, x = self.getLine(self.getSelectionEnd()).split("\t") #set anaphase onset self.cell.setAnOn(frame) for i in range(self.getLineCount()): # very unelegantly solved, but it works. blFr, blDist, blAOCol = self.getLine(i).split("\t") self.setLine(i, blFr + "\t" + blDist + "\t") frame, distance, AOCol = self.getLine(self.getSelectionEnd()).split("\t") # get old line self.setLine(self.getSelectionEnd(), frame + "\t" + distance + "\tX") # setFocus back to tw,tp self.mF.setSaveActive() print "Anaphase set to", self.cell.getAnOn() def delVal(self): frame, distance, AOCol = self.getLine(self.getSelectionEnd()).split("\t") self.setLine(self.getSelectionEnd(), frame + "\tNA" + "\t" + AOCol) # - other methods def openImp(self, path): imp = ImagePlus(path) # open associated tif file imp.show() imp.getWindow().setLocationAndSize(280, 120, imp.getWidth()*4, imp.getHeight()*4) # int x, int y, int width, int height return imp def getImp(self): return self.imp def getXYZtable(self): return self.XYZtable def closeWindows(self): self.imp.close() WindowManager.removeWindow(self.window) self.window.dispose()