Beispiel #1
0
class DatabasePanel(JPanel, ActionListener):
    __metaclass__ = Singleton

    def __init__(self):
        super(DatabasePanel, self).__init__()
        self._button = None
        self._text_field = None

    def actionPerformed(self, event):
        database_path = UIHelpers.choose_file()
        if database_path:
            if Application.get_instance().execute(
                    SetDomainDictValueCommand(
                        SetDomainDictValueCommand.TYPE_PERSISTENCE,
                        'database_path', database_path)):
                self._text_field.setText(database_path)

    def display(self, values):
        self._prepare_components(values)

    def _prepare_components(self, values):
        self._text_field = JTextField()
        self._text_field.setColumns(30)
        self._text_field.setEditable(False)
        self._text_field.setText(values['database_path'])
        self.add(self._text_field)
        button = JButton('Save as...')
        button.addActionListener(self)
        self.add(button)
class TextFieldPanel(JPanel, FocusListener):
    __metaclass__ = Singleton

    def __init__(self):
        super(TextFieldPanel, self).__init__()
        self._text_field = None

    def focusGained(self, event):
        pass

    def focusLost(self, event):
        Application.get_instance().execute(
            SetDomainDictValueCommand(
                self._get_domain_dict_type(), self._get_domain_dict_key(),
                InfrastructureHelpers.split(self._text_field.getText())))

    def display(self, values):
        self._prepare_components(values)

    def _prepare_components(self, values):
        self._text_field = JTextField()
        self._text_field.setColumns(30)
        self._text_field.setEditable(True)
        self._text_field.setText(
            InfrastructureHelpers.join(values[self._get_domain_dict_key()]))
        self._text_field.addFocusListener(self)
        self.add(self._text_field)
Beispiel #3
0
class TagPanel(JPanel, DocumentListener):
    __metaclass__ = Singleton

    def __init__(self):
        super(TagPanel, self).__init__()
        self._text_field = None

    def changeUpdate(self, event):
        self._update()

    def insertUpdate(self, event):
        self._update()

    def removeUpdate(self, event):
        self._update()

    def display(self, values):
        self.add(JLabel('<html><b>Tags:</b></html>'))
        self._text_field = JTextField()
        self._text_field.setColumns(20)
        self._text_field.setEditable(True)
        self._text_field.setText(InfrastructureHelpers.join(values['tags']))
        self._text_field.getDocument().addDocumentListener(self)
        self.add(self._text_field)

    def _update(self):
        Application.get_instance().execute(SetDomainDictValueCommand(
            SetDomainDictValueCommand.TYPE_VISIBLE_ITEMS,
            'tags',
            InfrastructureHelpers.split(self._text_field.getText())
        ))
Beispiel #4
0
 def addDetails(self):
     jf0 = JFrame()
     jf0.setTitle("Add Issue");
     jf0.setLayout(None);
     
     txtEnterIssue = JTextField();
     txtEnterIssue.setName("Enter Issue Name");
     txtEnterIssue.setToolTipText("Enter Issue Name Here");
     txtEnterIssue.setBounds(182, 58, 473, 40);
     jf0.add(txtEnterIssue);
     txtEnterIssue.setColumns(10);
     
     btnNewButton = JButton("Add");
     btnNewButton.setBounds(322, 178, 139, 41);
     jf0.add(btnNewButton);
     
     comboBox = JComboBox();
     comboBox.setMaximumRowCount(20);
     comboBox.setEditable(True);
     comboBox.setToolTipText("Objective Name");
     comboBox.setBounds(182, 125, 473, 40);
     jf0.add(comboBox);
     
     lblNewLabel = JLabel("Issue Name Here");
     lblNewLabel.setFont(Font("Tahoma", Font.PLAIN, 16));
     lblNewLabel.setBounds(25, 58, 130, 40);
     jf0.add(lblNewLabel);
     
     lblNewLabel_1 = JLabel("Objective Name");
     lblNewLabel_1.setFont(Font("Tahoma", Font.PLAIN, 16));
     lblNewLabel_1.setBounds(25, 125, 130, 40);
     jf0.add(lblNewLabel_1);
     jf0.setVisible(True)
     jf0.setBounds(400, 300, 700, 300)
     jf0.EXIT_ON_CLOSE
     
     txtEnterIssue.addKeyListener(self)
Beispiel #5
0
class CustomCellEditor(TreeCellEditor, ActionListener):
    """Renders the various tree edit controls (checkbox, tristate checkbox, text box etc.)"""
    def __init__(self, tree):
        TreeCellEditor.__init__(self)
        self.editor = None
        self.tree = tree

        flowLayout = FlowLayout(FlowLayout.LEFT, 0, 0)

        self.cbPanel = JPanel(flowLayout)
        self.cb = JCheckBox(actionPerformed=self.checked)
        self.cbPanel.add(self.cb)
        self.cbLabel = JLabel()
        self.cbPanel.add(self.cbLabel)

        self.tcbPanel = JPanel(flowLayout)
        self.tcb = TristateCheckBox(self.checked)
        self.tcbPanel.add(self.tcb)
        self.tcbLabel = JLabel()
        self.tcbPanel.add(self.tcbLabel)

        self.rbPanel = JPanel(flowLayout)
        self.rb = JRadioButton(actionPerformed=self.checked)
        self.rbPanel.add(self.rb)
        self.rbLabel = JLabel()
        self.rbPanel.add(self.rbLabel)

        self.tfPanel = JPanel(flowLayout)
        self.tfLabel = JLabel()
        self.tfPanel.add(self.tfLabel)
        self.tf = JTextField()
        self.tf.setColumns(12)
        self.tf.addActionListener(self)
        self.tfPanel.add(self.tf)

    def addCellEditorListener(self, l):
        """Register for edit events"""
        self.listener = l

    def isCellEditable(self, event):
        if event != None and isinstance(
                event.getSource(), JTree) and isinstance(event, MouseEvent):
            tree = event.getSource()
            path = tree.getPathForLocation(event.getX(), event.getY())
            userData = path.getLastPathComponent().getUserObject()
            if isinstance(userData,
                          TreeNodeData) and (not userData.getNodeType().isType(
                              [NodeType._comment, NodeType._menu
                               ])) and (userData.getVisible() > 0):
                return True

        return False

    def shouldSelectCell(self, event):
        # log.info("shouldSelectCell")
        return True

    def cancelCellEditing(self):
        # log.info("Cancel editing, please!")
        # super(CustomCellEditor, self).cancelCellEditing()
        pass

    def stopCellEditing(self):
        # log.info("stopCellEditing")
        if self.nodeData.getNodeType().isType([NodeType._text]):
            # log.info("stopCellEditing for sure!")
            self.nodeData.setValue(str(self.tf.getText()))
        return True

    def getTreeCellEditorComponent(self, tree, value, selected, expanded, leaf,
                                   row):
        """Return a swing edit control appropriate for the node type of the supplied value"""
        self.nodeData = self.getNodeUserData(value)
        if self.nodeData:
            text = self.nodeData.getText()
            t = self.nodeData.getNodeType()

            # Boolean checkbox
            if t.isType([NodeType._bool]):
                self.editor = self.cbPanel
                self.cbLabel.setText(text)
                if self.nodeData.getTriValue() > 0:
                    self.cb.setSelected(True)
                else:
                    self.cb.setSelected(False)

            # Tristate checkbox
            elif t.isType([NodeType._tri]):
                # log.info("getTreeCellEditorComponent tristate")
                self.editor = self.tcbPanel
                self.tcbLabel.setText(text)
                self.tcb.setTriState(self.nodeData.getTriValue())

            # Radio button
            elif t.isType([NodeType._radio]):
                self.editor = self.rbPanel
                self.rbLabel.setText(text)
                if self.nodeData.getTriValue() > 0:
                    self.rb.setSelected(True)
                else:
                    self.rb.setSelected(False)

            # Text field
            elif t.isType([NodeType._text]):
                self.editor = self.tfPanel
                self.tfLabel.setText(str(self.nodeData.getText()) + ":")
                self.tf.setText(str(self.nodeData.getValue()))

            else:
                self.editor = self.tcb
                self.editor.setText(text)

        return self.editor

    def getNodeUserData(self, value):
        """Gets the TreeNodeData from the tree node"""
        if isinstance(value, DefaultMutableTreeNode):
            nodeData = value.getUserObject()
            if isinstance(nodeData, TreeNodeData):
                return nodeData

        return None

    def getCellEditorValue(self):
        newNode = TreeNodeData(self.nodeData.knode, self.tree)

        if isinstance(self.editor, JTextField):
            newNode.setValue(str(self.editor.getText()))

        return newNode

    def checked(self, e):
        """Updates the node data when a checkbox has been clicked"""
        control = e.getSource()

        if isinstance(control, TristateCheckBox):
            # log.info("tristate checked")
            self.nodeData.setTriValue(control.getTriState())
        else:
            # log.info("checkbox checked")
            if control.isSelected():
                self.nodeData.setValue(2)
            else:
                self.nodeData.setValue(0)

    def actionPerformed(self, event):
        """ ENTER pressed in text field, stop editing."""
        tf = event.getSource()
        self.listener.editingStopped(ChangeEvent(tf))
Beispiel #6
0
class BurpExtender(IBurpExtender, ITab, IHttpListener,
                   IMessageEditorTabFactory):
    def registerExtenderCallbacks(self, callbacks):
        self._callbacks = callbacks
        self._helpers = callbacks.getHelpers()
        callbacks.setExtensionName("HaE(Highlighter and Extractor)")
        self._stdout = PrintWriter(callbacks.getStdout(), True)
        callbacks.registerHttpListener(self)
        callbacks.registerMessageEditorTabFactory(self)
        print 'HaE(Highlighter and Extractor)\nAuthor: Vulkey_Chen\nBlog: gh0st.cn\nTeam: MSTSEC'
        self._callbacks.customizeUiComponent(self.getUiComponent())
        self._callbacks.addSuiteTab(self)
        self.endColors = []

    def getTabCaption(self):
        return 'HaE'

    def createNewInstance(self, controller, editable):
        return MarkINFOTab(self, controller, editable)

    def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
        if messageIsRequest:
            return
        content = messageInfo.getResponse()
        # content 为响应正文信息
        info = getConfig()
        results = findContent(info, content)
        colorList = []
        if results != {}:
            for i in results:
                if info[i]['highlight'] == 1:
                    if info[i]['color'] == 'red':
                        messageInfo.setHighlight(info[i]['color'])
                        break
                    else:
                        colorList.append(info[i]['color'])

            if not messageInfo.getHighlight():
                colorsList = [colors.index(i) for i in colorList]
                colorsList.sort()
                # print(colorsList)
                self.helper(colorsList)
                endColor = [colors.index(x) for x in self.endColors]
                # print(endColor)
                messageInfo.setHighlight(colors[min(endColor)])

    # 颜色升级
    def helper(self, mylist):
        l = len(mylist)
        i = 0
        stack = []
        while i < l:
            if not stack:
                stack.append(mylist[i])
                i += 1
            else:
                if mylist[i] != stack[-1]:
                    stack.append(mylist[i])
                    i += 1
                else:
                    stack[-1] -= 1
                    i += 1

        if len(stack) == len(set(stack)):
            self.endColors = [colors[i] for i in stack]
        else:
            self.helper(stack)

    def addConfig(self, event):
        nameText = self.nameTextField.getText()
        regexText = self.regexTextField.getText()
        colorText = self.colorTextField.getText()
        isHighlight = int(self.highlightCheckBox.isSelected())
        isExtract = int(self.extractCheckBox.isSelected())
        if colorText in colors:
            with open(configFile, 'r+') as content:
                dicts = json.load(content)
                # 解决r+写入问题
                content.seek(0, 0)
                content.truncate()
                if nameText in dicts:
                    self.tipString.setText("Name is existed!")
                elif not (isHighlight or isExtract):
                    self.tipString.setText("Highlight or Extract?")
                else:
                    dicts[nameText] = {
                        "regex": regexText,
                        "highlight": isHighlight,
                        "extract": isExtract,
                        "color": colorText
                    }
                    content.write(jsbeautifier.beautify(json.dumps(dicts)))
                    #print(dicts)
                    self.tipString.setText("Save Successfully!")
        else:
            self.tipString.setText("Not in colors list.")

    def reloadConfig(self, event):
        with open(configFile, 'r') as content:
            self.configTextArea.setText(content.read())

    def getUiComponent(self):
        self.HaEPanel = JPanel()
        self.HaEPanel.setBorder(None)
        self.HaEPanel.setLayout(BorderLayout(0, 0))
        self.panel = JPanel()
        self.HaEPanel.add(self.panel, BorderLayout.NORTH)
        self.panel.setLayout(BorderLayout(0, 0))
        self.tabbedPane = JTabbedPane(JTabbedPane.TOP)
        self.panel.add(self.tabbedPane, BorderLayout.CENTER)
        self.setPanel = JPanel()
        self.tabbedPane.addTab("Set", None, self.setPanel, None)
        self.setPanel.setLayout(BorderLayout(0, 0))
        self.setPanel_1 = JPanel()
        self.setPanel.add(self.setPanel_1, BorderLayout.NORTH)
        self.nameString = JLabel("Name")
        self.setPanel_1.add(self.nameString)
        self.nameTextField = JTextField()
        self.setPanel_1.add(self.nameTextField)
        self.nameTextField.setColumns(10)
        self.regexString = JLabel("Regex")
        self.setPanel_1.add(self.regexString)
        self.regexTextField = JTextField()
        self.setPanel_1.add(self.regexTextField)
        self.regexTextField.setColumns(10)
        self.extractCheckBox = JCheckBox("Extract")
        self.setPanel_1.add(self.extractCheckBox)
        self.highlightCheckBox = JCheckBox("Highlight")
        self.setPanel_1.add(self.highlightCheckBox)
        self.setPanel_2 = JPanel()
        self.setPanel.add(self.setPanel_2)
        self.colorString = JLabel("Color")
        self.setPanel_2.add(self.colorString)
        self.colorTextField = JTextField()
        self.setPanel_2.add(self.colorTextField)
        self.colorTextField.setColumns(5)
        self.addBottun = JButton("Add", actionPerformed=self.addConfig)
        self.setPanel_2.add(self.addBottun)
        self.tipString = JLabel("")
        self.setPanel_2.add(self.tipString)
        self.configPanel = JPanel()
        self.tabbedPane.addTab("Config", None, self.configPanel, None)
        self.configPanel.setLayout(BorderLayout(0, 0))
        self.configString = JLabel("This is config file content.")
        self.configString.setHorizontalAlignment(SwingConstants.CENTER)
        self.configPanel.add(self.configString, BorderLayout.NORTH)
        self.configTextArea = JTextArea()
        self.configTextArea.setEnabled(False)
        self.configTextArea.setTabSize(4)
        self.configTextArea.setLineWrap(True)
        self.configTextArea.setRows(20)
        self.configPanel.add(self.configTextArea, BorderLayout.SOUTH)
        self.scrollPane = JScrollPane(self.configTextArea)
        self.configPanel.add(self.scrollPane, BorderLayout.SOUTH)
        self.reloadButton = JButton("Reload",
                                    actionPerformed=self.reloadConfig)
        self.configPanel.add(self.reloadButton, BorderLayout.CENTER)
        return self.HaEPanel
Beispiel #7
0
class BurpExtender(IBurpExtender, ITab, IContextMenuFactory, DocumentListener, ChangeListener):

    #
    # implement IBurpExtender
    #
    def	registerExtenderCallbacks(self, callbacks):
        print "PhantomJS RIA Crawler extension"
        print "Nikolay Matyunin @autorak <*****@*****.**>"

        # keep a reference to our callbacks object and helpers object
        self._callbacks = callbacks
        self._helpers = callbacks.getHelpers()

        # extension name
        callbacks.setExtensionName("Phantom RIA Crawler")

        # Create Tab UI components
        self._jPanel = JPanel()
        self._jPanel.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));

        _titleLabel = JLabel("Phantom RIA Crawler", SwingConstants.LEFT)
        _titleLabelFont = _titleLabel.font
        _titleLabelFont = _titleLabelFont.deriveFont(Font.BOLD, 12);
        _titleLabel.setFont(_titleLabelFont);
        _titleLabel.setForeground(Color(230, 142, 11))

        self._addressTextField = JTextField('')
        self._addressTextField.setColumns(50)
        _addressTextLabel = JLabel("Target URL:", SwingConstants.RIGHT)
        self._addressTextField.getDocument().addDocumentListener(self)

        self._phantomJsPathField = JTextField('phantomjs') # TODO: set permanent config value
        self._phantomJsPathField.setColumns(50)
        _phantomJsPathLabel = JLabel("PhantomJS path:", SwingConstants.RIGHT)

        self._startButton = JToggleButton('Start', actionPerformed=self.startToggled)
        self._startButton.setEnabled(False)

        _requestsMadeLabel = JLabel("DEPs found:", SwingConstants.RIGHT)
        self._requestsMadeInfo = JLabel("", SwingConstants.LEFT)
        _statesFoundLabel = JLabel("States found:", SwingConstants.RIGHT)
        self._statesFoundInfo = JLabel("", SwingConstants.LEFT)

        _separator = JSeparator(SwingConstants.HORIZONTAL)

        _configLabel = JLabel("Crawling configuration:")
        self._configButton = JButton("Load config", actionPerformed=self.loadConfigClicked)
        self._configFile = ""

        _listenersLabel= JLabel("Burp proxy listener:", SwingConstants.RIGHT)
        self._listenersCombo = JComboBox()
        self._configTimer = Timer(5000, None)
        self._configTimer.actionPerformed = self._configUpdated
        self._configTimer.stop()
        self._configUpdated(None)

        self._commandClient = CommandClient(self)

        # Layout management
        self._groupLayout = GroupLayout(self._jPanel)
        self._jPanel.setLayout(self._groupLayout)
        self._groupLayout.setAutoCreateGaps(True)
        self._groupLayout.setAutoCreateContainerGaps(True)

        self._groupLayout.setHorizontalGroup(self._groupLayout.createParallelGroup()
            .addComponent(_titleLabel)
            .addGroup(self._groupLayout.createSequentialGroup()
                .addComponent(_addressTextLabel)
                .addGroup(self._groupLayout.createParallelGroup()
                    .addComponent(self._addressTextField, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE)
                    .addGroup(self._groupLayout.createSequentialGroup()
                        .addComponent(_requestsMadeLabel)
                        .addComponent(self._requestsMadeInfo))
                    .addGroup(self._groupLayout.createSequentialGroup()
                        .addComponent(_statesFoundLabel)
                        .addComponent(self._statesFoundInfo)))
                .addComponent(self._startButton))
            .addComponent(_separator)
            .addGroup(self._groupLayout.createSequentialGroup()
                .addComponent(_configLabel)
                .addComponent(self._configButton))
            .addGroup(self._groupLayout.createSequentialGroup()
                .addComponent(_phantomJsPathLabel)
                .addComponent(self._phantomJsPathField, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE))
            .addGroup(self._groupLayout.createSequentialGroup()
                .addComponent(_listenersLabel)
                .addComponent(self._listenersCombo, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE))
        )

        self._groupLayout.setVerticalGroup(self._groupLayout.createSequentialGroup()
            .addComponent(_titleLabel)
            .addGroup(self._groupLayout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                .addComponent(_addressTextLabel)
                .addComponent(self._addressTextField)
                .addComponent(self._startButton))
            .addGroup(self._groupLayout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                .addComponent(_requestsMadeLabel)
                .addComponent(self._requestsMadeInfo))
            .addGroup(self._groupLayout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                .addComponent(_statesFoundLabel)
                .addComponent(self._statesFoundInfo))
            .addComponent(_separator, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
            .addGroup(self._groupLayout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                .addComponent(_configLabel)
                .addComponent(self._configButton))
            .addGroup(self._groupLayout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                .addComponent(_phantomJsPathLabel)
                .addComponent(self._phantomJsPathField))
            .addGroup(self._groupLayout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                .addComponent(_listenersLabel)
                .addComponent(self._listenersCombo))
        )

        self._groupLayout.linkSize(SwingConstants.HORIZONTAL, _configLabel, _phantomJsPathLabel);
        self._groupLayout.linkSize(SwingConstants.HORIZONTAL, _configLabel, _listenersLabel);
        self._groupLayout.linkSize(SwingConstants.HORIZONTAL, _statesFoundLabel, _requestsMadeLabel);


        # context menu data
        self._contextMenuData = None;
        self._running = False;

        # register callbacks
        callbacks.customizeUiComponent(self._jPanel)
        callbacks.registerContextMenuFactory(self)
        callbacks.addSuiteTab(self)

        return

    #
    # implement ITab and Tab ChangeListener
    #
    def getTabCaption(self):
        return "Phantom RIA Crawler"
    def getUiComponent(self):
        return self._jPanel
    def stateChanged(self, ev):
        self._configUpdated()

    def _configUpdated(self, ev):
        config = self._callbacks.saveConfig()

        # update proxy listeners
        index = 0
        listeners = DefaultComboBoxModel()
        while (("proxy.listener" + str(index)) in config):
            listenerItem = config["proxy.listener" + str(index)]
            listenerItems = listenerItem.split(".")
            if (listenerItems[0] == "1"):
                address = ".".join(listenerItems[2][1:].split("|"))
                if (len(address) == 0):
                    address = "127.0.0.1"
                listeners.addElement(address + " : " + listenerItems[1])

            index = index + 1
        self._listenersCombo.setModel(listeners)
        return;

    #
    # implement button actions
    #
    def startToggled(self, ev):
        if (self._startButton.getModel().isSelected()):
            try:
                os.chdir(sys.path[0] + os.sep + "riacrawler" + os.sep + "scripts")
            except Exception as e:
                print >> sys.stderr, "RIA crawler scripts loading error", "I/O error({0}): {1}".format(e.errno, e.strerror)
                self._startButton.setSelected(False)
                return

            phantomJsPath = self._phantomJsPathField.text
            target = self._addressTextField.text

            config = "crawler.config"
            if (self._configFile):
                config = self._configFile

            listenerAddress = self._listenersCombo.getSelectedItem().replace(" ", "")
            p = Popen("{0} --proxy={3} main.js --target={1} --config={2}".format(phantomJsPath, target, config, listenerAddress), shell=True)
            self._running = True
            self._requestsMadeInfo.setText("")
            self._statesFoundInfo.setText("")
            self._commandClient.startCrawling()
        else:
            if (self._running):
                self._commandClient.stopCrawling()
            self._running = False

    def syncCrawlingState(self, result):
        print "RIA crawling state: ", result
        self._requestsMadeInfo.setText(str(result["requests_made"]))
        self._statesFoundInfo.setText(str(result["states_detected"]))
        if (result["running"] == False):
            self._commandClient.stopCrawling()
            self._running = False
            self._startButton.setSelected(False)

    def loadConfigClicked(self, ev):
        openFile = JFileChooser();
        openFile.showOpenDialog(None);
        self._configFile = openFile.getSelectedFile()

    #
    # implement DocumentListener for _addressTextField
    #
    def removeUpdate(self, ev):
        self.updateStartButton()
    def insertUpdate(self, ev):
        self.updateStartButton()
    def updateStartButton(self):
        self._startButton.setEnabled(len(self._addressTextField.text) > 0)


    #
    # implement IContextMenuFactory
    #
    def createMenuItems(self, contextMenuInvocation):
        menuItemList = ArrayList()

        context = contextMenuInvocation.getInvocationContext()
        if (context == IContextMenuInvocation.CONTEXT_MESSAGE_VIEWER_REQUEST or context == IContextMenuInvocation.CONTEXT_MESSAGE_EDITOR_REQUEST or
            context == IContextMenuInvocation.CONTEXT_PROXY_HISTORY or context == IContextMenuInvocation.CONTEXT_TARGET_SITE_MAP_TABLE):

            self._contextMenuData = contextMenuInvocation.getSelectedMessages()
            menuItemList.add(JMenuItem("Send to Phantom RIA Crawler", actionPerformed = self.menuItemClicked))

        return menuItemList


    def menuItemClicked(self, event):
        if (self._running == True):
            self._callbacks.issueAlert("Can't set data to Phantom RIA Crawler: crawling is running already.")
            return;

        dataIsSet = False;
        for message in self._contextMenuData:
            request = self._helpers.analyzeRequest(message)

            url = request.getUrl().toString()
            print url
            if (url):
                dataisSet = True;
                self._addressTextField.setText(url)
Beispiel #8
0
class ConfigurableConfigPanel(ConfigPanel, ActionListener, DocumentListener, ChangeListener):
    """ generated source for class ConfigurableConfigPanel """
    serialVersionUID = 1L
    associatedFile = File()
    associatedFileField = JTextField()
    params = JSONObject()
    savedParams = str()
    loadButton = JButton()
    saveAsButton = JButton()
    saveButton = JButton()
    name = JTextField()
    strategy = JComboBox()
    metagameStrategy = JComboBox()
    stateMachine = JComboBox()
    cacheStateMachine = JCheckBox()
    maxPlys = JSpinner()
    heuristicFocus = JSpinner()
    heuristicMobility = JSpinner()
    heuristicOpponentFocus = JSpinner()
    heuristicOpponentMobility = JSpinner()
    mcDecayRate = JSpinner()
    rightPanel = JPanel()

    def __init__(self):
        """ generated source for method __init__ """
        super(ConfigurableConfigPanel, self).__init__(GridBagLayout())
        leftPanel = JPanel(GridBagLayout())
        leftPanel.setBorder(TitledBorder("Major Parameters"))
        self.rightPanel = JPanel(GridBagLayout())
        self.rightPanel.setBorder(TitledBorder("Minor Parameters"))
        self.strategy = JComboBox([None]*)
        self.metagameStrategy = JComboBox([None]*)
        self.stateMachine = JComboBox([None]*)
        self.cacheStateMachine = JCheckBox()
        self.maxPlys = JSpinner(SpinnerNumberModel(1, 1, 100, 1))
        self.heuristicFocus = JSpinner(SpinnerNumberModel(1, 0, 10, 1))
        self.heuristicMobility = JSpinner(SpinnerNumberModel(1, 0, 10, 1))
        self.heuristicOpponentFocus = JSpinner(SpinnerNumberModel(1, 0, 10, 1))
        self.heuristicOpponentMobility = JSpinner(SpinnerNumberModel(1, 0, 10, 1))
        self.mcDecayRate = JSpinner(SpinnerNumberModel(0, 0, 99, 1))
        self.name = JTextField()
        self.name.setColumns(20)
        self.name.setText("Player #" + Random().nextInt(100000))
        self.loadButton = JButton(loadButtonMethod())
        self.saveButton = JButton(saveButtonMethod())
        self.saveAsButton = JButton(saveAsButtonMethod())
        self.associatedFileField = JTextField()
        self.associatedFileField.setEnabled(False)
        buttons = JPanel()
        buttons.add(self.loadButton)
        buttons.add(self.saveButton)
        buttons.add(self.saveAsButton)
        nRow = 0
        leftPanel.add(JLabel("Name"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
        __nRow_0 = nRow
        nRow += 1
        leftPanel.add(self.name, GridBagConstraints(1, __nRow_0, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, Insets(5, 5, 5, 5), 5, 5))
        leftPanel.add(JLabel("Gaming Strategy"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
        __nRow_1 = nRow
        nRow += 1
        leftPanel.add(self.strategy, GridBagConstraints(1, __nRow_1, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, Insets(5, 5, 5, 5), 5, 5))
        leftPanel.add(JLabel("Metagame Strategy"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
        __nRow_2 = nRow
        nRow += 1
        leftPanel.add(self.metagameStrategy, GridBagConstraints(1, __nRow_2, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, Insets(5, 5, 5, 5), 5, 5))
        leftPanel.add(JLabel("State Machine"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
        __nRow_3 = nRow
        nRow += 1
        leftPanel.add(self.stateMachine, GridBagConstraints(1, __nRow_3, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, Insets(5, 5, 5, 5), 5, 5))
        __nRow_4 = nRow
        nRow += 1
        leftPanel.add(buttons, GridBagConstraints(1, __nRow_4, 2, 1, 1.0, 1.0, GridBagConstraints.SOUTHEAST, GridBagConstraints.NONE, Insets(5, 5, 0, 5), 0, 0))
        leftPanel.add(self.associatedFileField, GridBagConstraints(0, nRow, 2, 1, 1.0, 0.0, GridBagConstraints.SOUTHEAST, GridBagConstraints.HORIZONTAL, Insets(0, 5, 5, 5), 0, 0))
        layoutRightPanel()
        add(leftPanel, GridBagConstraints(0, 0, 1, 1, 0.0, 1.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, Insets(5, 5, 5, 5), 5, 5))
        add(self.rightPanel, GridBagConstraints(1, 0, 1, 1, 1.0, 1.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, Insets(5, 5, 5, 5), 5, 5))
        self.params = JSONObject()
        syncJSONtoUI()
        self.strategy.addActionListener(self)
        self.metagameStrategy.addActionListener(self)
        self.stateMachine.addActionListener(self)
        self.cacheStateMachine.addActionListener(self)
        self.maxPlys.addChangeListener(self)
        self.heuristicFocus.addChangeListener(self)
        self.heuristicMobility.addChangeListener(self)
        self.heuristicOpponentFocus.addChangeListener(self)
        self.heuristicOpponentMobility.addChangeListener(self)
        self.mcDecayRate.addChangeListener(self)
        self.name.getDocument().addDocumentListener(self)

    def layoutRightPanel(self):
        """ generated source for method layoutRightPanel """
        nRow = 0
        self.rightPanel.removeAll()
        self.rightPanel.add(JLabel("State machine cache?"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
        __nRow_5 = nRow
        nRow += 1
        self.rightPanel.add(self.cacheStateMachine, GridBagConstraints(1, __nRow_5, 1, 1, 1.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
        if self.strategy.getSelectedItem().__str__() == "Heuristic":
        __nRow_6 = nRow
        nRow += 1
        __nRow_7 = nRow
        nRow += 1
        __nRow_8 = nRow
        nRow += 1
        __nRow_9 = nRow
        nRow += 1
        __nRow_10 = nRow
        nRow += 1
            self.rightPanel.add(JLabel("Max plys?"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
            self.rightPanel.add(self.maxPlys, GridBagConstraints(1, __nRow_6, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
            self.rightPanel.add(JLabel("Focus Heuristic Weight"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
            self.rightPanel.add(self.heuristicFocus, GridBagConstraints(1, __nRow_7, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
            self.rightPanel.add(JLabel("Mobility Heuristic Weight"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
            self.rightPanel.add(self.heuristicMobility, GridBagConstraints(1, __nRow_8, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
            self.rightPanel.add(JLabel("Opponent Focus Heuristic Weight"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
            self.rightPanel.add(self.heuristicOpponentFocus, GridBagConstraints(1, __nRow_9, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
            self.rightPanel.add(JLabel("Opponent Mobility Heuristic Weight"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
            self.rightPanel.add(self.heuristicOpponentMobility, GridBagConstraints(1, __nRow_10, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
        if self.strategy.getSelectedItem().__str__() == "Monte Carlo":
        __nRow_11 = nRow
        nRow += 1
            self.rightPanel.add(JLabel("Goal Decay Rate"), GridBagConstraints(0, nRow, 1, 1, 0.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
            self.rightPanel.add(self.mcDecayRate, GridBagConstraints(1, __nRow_11, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
        __nRow_12 = nRow
        nRow += 1
        self.rightPanel.add(JLabel(), GridBagConstraints(2, __nRow_12, 1, 1, 1.0, 1.0, GridBagConstraints.SOUTHEAST, GridBagConstraints.NONE, Insets(5, 5, 5, 5), 5, 5))
        self.rightPanel.repaint()

    @SuppressWarnings("unchecked")
    def getParameter(self, name, defaultValue):
        """ generated source for method getParameter """
        try:
            if self.params.has(name):
                return self.params.get(name)
            else:
                return defaultValue
        except JSONException as je:
            return defaultValue

    def actionPerformed(self, arg0):
        """ generated source for method actionPerformed """
        if arg0.getSource() == self.strategy:
            self.layoutRightPanel()
        syncJSONtoUI()

    def changedUpdate(self, e):
        """ generated source for method changedUpdate """
        syncJSONtoUI()

    def insertUpdate(self, e):
        """ generated source for method insertUpdate """
        syncJSONtoUI()

    def removeUpdate(self, e):
        """ generated source for method removeUpdate """
        syncJSONtoUI()

    def stateChanged(self, arg0):
        """ generated source for method stateChanged """
        syncJSONtoUI()

    def syncJSONtoUI(self):
        """ generated source for method syncJSONtoUI """
        if settingUI:
            return
        self.params = getJSONfromUI()
        self.saveButton.setEnabled(self.savedParams == None or not self.params.__str__() == self.savedParams)

    def getJSONfromUI(self):
        """ generated source for method getJSONfromUI """
        newParams = JSONObject()
        try:
            if not self.name.getText().isEmpty():
                newParams.put("name", self.name.getText())
            newParams.put("strategy", self.strategy.getSelectedItem().__str__())
            newParams.put("metagameStrategy", self.metagameStrategy.getSelectedItem().__str__())
            newParams.put("stateMachine", self.stateMachine.getSelectedItem().__str__())
            newParams.put("cacheStateMachine", self.cacheStateMachine.isSelected())
            newParams.put("maxPlys", self.maxPlys.getModel().getValue())
            newParams.put("heuristicFocus", self.heuristicFocus.getModel().getValue())
            newParams.put("heuristicMobility", self.heuristicMobility.getModel().getValue())
            newParams.put("heuristicOpponentFocus", self.heuristicOpponentFocus.getModel().getValue())
            newParams.put("heuristicOpponentMobility", self.heuristicOpponentMobility.getModel().getValue())
            newParams.put("mcDecayRate", self.mcDecayRate.getModel().getValue())
        except JSONException as je:
            je.printStackTrace()
        return newParams

    settingUI = False

    def setUIfromJSON(self):
        """ generated source for method setUIfromJSON """
        self.settingUI = True
        try:
            if self.params.has("name"):
                self.name.setText(self.params.getString("name"))
            if self.params.has("strategy"):
                self.strategy.setSelectedItem(self.params.getString("strategy"))
            if self.params.has("metagameStrategy"):
                self.metagameStrategy.setSelectedItem(self.params.getString("metagameStrategy"))
            if self.params.has("stateMachine"):
                self.stateMachine.setSelectedItem(self.params.getString("stateMachine"))
            if self.params.has("cacheStateMachine"):
                self.cacheStateMachine.setSelected(self.params.getBoolean("cacheStateMachine"))
            if self.params.has("maxPlys"):
                self.maxPlys.getModel().setValue(self.params.getInt("maxPlys"))
            if self.params.has("heuristicFocus"):
                self.heuristicFocus.getModel().setValue(self.params.getInt("heuristicFocus"))
            if self.params.has("heuristicMobility"):
                self.heuristicMobility.getModel().setValue(self.params.getInt("heuristicMobility"))
            if self.params.has("heuristicOpponentFocus"):
                self.heuristicOpponentFocus.getModel().setValue(self.params.getInt("heuristicOpponentFocus"))
            if self.params.has("heuristicOpponentMobility"):
                self.heuristicOpponentMobility.getModel().setValue(self.params.getInt("heuristicOpponentMobility"))
            if self.params.has("mcDecayRate"):
                self.mcDecayRate.getModel().setValue(self.params.getInt("mcDecayRate"))
        except JSONException as je:
            je.printStackTrace()
        finally:
            self.settingUI = False

    def loadParamsJSON(self, fromFile):
        """ generated source for method loadParamsJSON """
        if not fromFile.exists():
            return
        self.associatedFile = fromFile
        self.associatedFileField.setText(self.associatedFile.getPath())
        self.params = JSONObject()
        try:
            try:
                while (line = br.readLine()) != None:
                    pdata.append(line)
            finally:
                br.close()
            self.params = JSONObject(pdata.__str__())
            self.savedParams = self.params.__str__()
            self.setUIfromJSON()
            self.syncJSONtoUI()
        except Exception as e:
            e.printStackTrace()

    def saveParamsJSON(self, saveAs):
        """ generated source for method saveParamsJSON """
        try:
            if saveAs or self.associatedFile == None:
                fc.setFileFilter(PlayerFilter())
                if returnVal == JFileChooser.APPROVE_OPTION and fc.getSelectedFile() != None:
                    if toFile.__name__.contains("."):
                        self.associatedFile = File(toFile.getParentFile(), toFile.__name__.substring(0, toFile.__name__.lastIndexOf(".")) + ".player")
                    else:
                        self.associatedFile = File(toFile.getParentFile(), toFile.__name__ + ".player")
                    self.associatedFileField.setText(self.associatedFile.getPath())
                else:
                    return
            bw.write(self.params.__str__())
            bw.close()
            self.savedParams = self.params.__str__()
            self.syncJSONtoUI()
        except IOException as ie:
            ie.printStackTrace()

    def saveButtonMethod(self):
        """ generated source for method saveButtonMethod """
        return AbstractAction("Save")

    def saveAsButtonMethod(self):
        """ generated source for method saveAsButtonMethod """
        return AbstractAction("Save As")

    def loadButtonMethod(self):
        """ generated source for method loadButtonMethod """
        return AbstractAction("Load")

    class PlayerFilter(FileFilter):
        """ generated source for class PlayerFilter """
        def accept(self, f):
            """ generated source for method accept """
            if f.isDirectory():
                return True
            return f.__name__.endsWith(".player")

        def getDescription(self):
            """ generated source for method getDescription """
            return "GGP Players (*.player)"
Beispiel #9
0
class GUI(ITab, ActionListener, KeyAdapter):
    def __init__(self):
       return
        
    def getTabCaption(self):
        return "BurpExtension"
    
    def getUiComponent(self):
        return self.UI()
        
    def UI(self):
        self.val=""
        self.tabbedPane = JTabbedPane(JTabbedPane.TOP)
        self.panel = JPanel()
        self.tabbedPane.addTab("App Details", None, self.panel, None) # Details of app currently under pentest would be pulled into here through API
        self.panel_1 =  JPanel()
        self.tabbedPane.addTab("Results", None, self.panel_1, None) # passed results would go inside this and connected to reporting system via API
        self.panel_2 =  JPanel()
        self.tabbedPane.addTab("Failed Cases", None, self.panel_2, None) #list of failed tests would go inside this
        self.textField = JTextField()
        self.textField.setBounds(12, 13, 207, 39)
        self.panel.add(self.textField)
        self.textField.setColumns(10)
        self.comboBox = JComboBox()
        self.comboBox.setEditable(True)
        self.comboBox.addItem("Default")
        self.comboBox.addItem("High")
        self.comboBox.addItem("Low")
        self.comboBox.setBounds(46, 65, 130, 28)
        self.comboBox.addActionListener(self)
        self.panel.add(self.comboBox) 
        self.btnNewButton = JButton("Submit")
        self.btnNewButton.setBounds(60, 125, 97, 25)
        self.panel.add(self.btnNewButton)
        editorPane = JEditorPane();
        editorPane.setBounds(12, 35, 1000, 800);
        self.panel_2.add(editorPane);
        self.panel_2.setLayout(BorderLayout())
        return self.tabbedPane
    
    def getAppRating(self):
        sys.stdout.write(str(self.val))      
        return str(self.val)
        
    def actionPerformed(self, e):
        if(e.getSource()==self.comboBox):
            self.val = self.comboBox.getSelectedItem()
        else:
            self.addDetails()
        
    def addDetails(self):
        jf0 = JFrame()
        jf0.setTitle("Add Issue");
        jf0.setLayout(None);
        
        txtEnterIssue = JTextField();
        txtEnterIssue.setName("Enter Issue Name");
        txtEnterIssue.setToolTipText("Enter Issue Name Here");
        txtEnterIssue.setBounds(182, 58, 473, 40);
        jf0.add(txtEnterIssue);
        txtEnterIssue.setColumns(10);
        
        btnNewButton = JButton("Add");
        btnNewButton.setBounds(322, 178, 139, 41);
        jf0.add(btnNewButton);
        
        comboBox = JComboBox();
        comboBox.setMaximumRowCount(20);
        comboBox.setEditable(True);
        comboBox.setToolTipText("Objective Name");
        comboBox.setBounds(182, 125, 473, 40);
        jf0.add(comboBox);
        
        lblNewLabel = JLabel("Issue Name Here");
        lblNewLabel.setFont(Font("Tahoma", Font.PLAIN, 16));
        lblNewLabel.setBounds(25, 58, 130, 40);
        jf0.add(lblNewLabel);
        
        lblNewLabel_1 = JLabel("Objective Name");
        lblNewLabel_1.setFont(Font("Tahoma", Font.PLAIN, 16));
        lblNewLabel_1.setBounds(25, 125, 130, 40);
        jf0.add(lblNewLabel_1);
        jf0.setVisible(True)
        jf0.setBounds(400, 300, 700, 300)
        jf0.EXIT_ON_CLOSE
        
        txtEnterIssue.addKeyListener(self)
    
    def keyPressed(self, e):
               
        self.search_string.__add__(self.search_string)
        self.jtf1.setText(self.search_string)
        sys.stdout.write(self.search_string)