def makeTree(self): #----------------------------------------------------------------------- # First, build the hierarchy of Tree nodes #----------------------------------------------------------------------- root = DefaultMutableTreeNode('Root Node') for name in 'Parent 1,Parent 2'.split(','): here = DefaultMutableTreeNode(name) for child in 'Child 1,Child 2'.split(','): here.add(DefaultMutableTreeNode(child)) root.add(here) #----------------------------------------------------------------------- # Next, use the hierarchy to create a Tree Model, with a listener #----------------------------------------------------------------------- model = DefaultTreeModel(root, treeModelListener=myTreeModelListener()) #----------------------------------------------------------------------- # Then, build our editable JTree() using this model #----------------------------------------------------------------------- tree = JTree(model, editable=1, showsRootHandles=1, valueChanged=self.select) #----------------------------------------------------------------------- # Only allow one node to be selectable at a time #----------------------------------------------------------------------- tree.getSelectionModel().setSelectionMode( TreeSelectionModel.SINGLE_TREE_SELECTION) return tree
def __init__(self): frame = JFrame("jTODO", defaultCloseOperation=JFrame.EXIT_ON_CLOSE, size=(400, 350), layout=BorderLayout()) treeTrunk = DefaultMutableTreeNode('Contexts') treeTrunk.add(DefaultMutableTreeNode('Sample Context')) self.tree = JTree(treeTrunk) leftPanel = JPanel() leftScrollPane = JScrollPane(self.tree) #leftScrollPane.setPreferredSize( Dimension( 300,250 ) ) leftScrollPane.getViewport().setView((self.tree)) leftPanel.add(leftScrollPane) label2 = JLabel("right") rightPanel = JPanel() rightPanel.add(label2) splitPane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT) splitPane.setLeftComponent(leftPanel) splitPane.setRightComponent(rightPanel) #splitPane.setDividerLocation( 200 ) frame.add(splitPane) frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE) frame.show()
def groupTree(self): data = AdminTask.help('-commandGroups').expandtabs().splitlines() root = DefaultMutableTreeNode('command groups') for line in data[1:]: mo = re.match('([a-zA-Z ]+) -', line) if mo: groupName = mo.group(1) group = None text = AdminTask.help(groupName) cmds = text.find('Commands:') if cmds > 0: for line in text[cmds + 9:].splitlines(): mo = re.match('([a-zA-Z_2]+) -', line) if mo: if not group: group = DefaultMutableTreeNode(groupName) group.add(DefaultMutableTreeNode(mo.group(1))) if group: root.add(group) else: print 'Empty group:', groupName return JTree( root, rootVisible=0 #, # valueChanged = self.select )
def set_checklist_tree(self): self.checklist_tree = DefaultMutableTreeNode("HUNT - Methodology") for item in self.checklist: node = DefaultMutableTreeNode(item) self.checklist_tree.add(node) is_functionality = node.toString() == "Functionality" if is_functionality: functionality_node = node functionality = self.checklist["Functionality"] # Sorts the functionality by name and by test name functionality_list = [] for functionality_name in functionality: functionality_list.append(functionality_name) for functionality_name in sorted(functionality_list): tests = functionality[functionality_name]["tests"] node = DefaultMutableTreeNode(functionality_name) tests_list = [] for test_name in tests: tests_list.append(test_name) for test_name in sorted(tests_list): node.add(DefaultMutableTreeNode(test_name)) functionality_node.add(node)
def make_tree(self): print('make_tree') root = DefaultMutableTreeNode(self.exper.name) sb = br.SimilarityBuilder() for hseg in self.exper.hsegs(): all_file_dict = hseg.file_dict() all_file_dict.update(hseg.cell_file_dict()) all_file_dict.update(hseg.bin_file_dict()) sb.add_group(hseg.name, all_file_dict) simprofile, comparisons = sb.simprofile_comparison() sim_str = '' for val in simprofile: sim_str += str(val) + '\n' tp = JTextArea(sim_str) stp = JScrollPane() stp.getViewport().setView(tp) # # stp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS); # stp.setPreferredSize(Dimension(250, 250)); # tp.setPreferredSize(Dimension(250, 250)) stp_panel = JPanel(BorderLayout()) stp_panel.add(tp, BorderLayout.CENTER) # self.add(stp_panel, 'grow') for hseg in self.exper.hsegs(): hseg_node = DefaultMutableTreeNode(hseg.name) root.add(hseg_node) if len(comparisons[hseg.name]) > 0: for definer, file_names in comparisons[hseg.name].items(): for file_name in file_names: node_str = definer + ': ' + file_name hseg_node.add(DefaultMutableTreeNode(node_str)) # for file_suf in hseg.file_dict() : # hseg_node.add(DefaultMutableTreeNode(file_suf)) self.tree = JTree(root) scrollPane = JScrollPane() scrollPane.getViewport().setView((self.tree)) # scrollPan # scrollPane.setPreferredSize(Dimension(300,250)) tree_panel = JPanel(BorderLayout()) tree_panel.add(scrollPane, BorderLayout.CENTER) combo_panel = JPanel(GridLayout(0, 2, 10, 10)) # combo_panel.setLayout(BoxLayout(combo_panel, BoxLayout.X_AXIS)) combo_panel.add(stp_panel) #, BorderLayout.LINE_START) combo_panel.add(tree_panel) #, BorderLayout.LINE_END) self.panel.add(combo_panel) # self.add(scrollPane, 'grow') self.revalidate()
def __appendCaseMethodsHelper(self, case, caseNode, metaName, entityName): ''' helper for appendCommands, appendFixture & appendHelpers ''' mtdMeta = DefaultMutableTreeNode(metaName) caseNode.add(mtdMeta) mtds = [edge.getNode2() for edge in case->(entity == entityName)] mtds.sort(cmpTc) for mtd in mtds: mtdNode = DefaultMutableTreeNode(mtd.label) mtdMeta.add(mtdNode)
def cellTree(self): # Use the cellName as the tree root node cell = AdminConfig.list('Cell') root = DefaultMutableTreeNode(self.getName(cell)) for node in AdminConfig.list('Node').splitlines(): here = DefaultMutableTreeNode(self.getName(node)) servers = AdminConfig.list('Server', node) for server in servers.splitlines(): leaf = DefaultMutableTreeNode(self.getName(server)) here.add(leaf) root.add(here) return JTree(root, editable=1)
def createTree(self,xnode): if xnode.hasChildNodes(): tnode = DefaultMutableTreeNode(xnode.getNodeName()) else: tnode = DefaultMutableTreeNode(xnode) return tnode child_nodes = xnode.getChildNodes() child_count = child_nodes.getLength() for i in range(child_count): element = child_nodes.item(i) if xnode.getTagName() == "table_row": continue if isinstance(element,ElementNode): tnode.add( self.createTree(child_nodes.item(i)) ) return tnode
def set_vuln_tree(self): self.vuln_tree = DefaultMutableTreeNode("Vulnerability Classes") vulns = self.json["issues"] # TODO: Sort the functionality by name and by vuln class for vuln_name in vulns: vuln = DefaultMutableTreeNode(vuln_name) self.vuln_tree.add(vuln) parameters = self.json["issues"][vuln_name]["params"] for parameter in parameters: param_node = DefaultMutableTreeNode(parameter) vuln.add(param_node)
def set_vuln_tree(self): self.vuln_tree = DefaultMutableTreeNode("HUNT Scanner") vulns = self.json["issues"] for vuln_name in sorted(vulns): vuln = DefaultMutableTreeNode(vuln_name) self.vuln_tree.add(vuln) parameters = self.json["issues"][vuln_name]["params"] for parameter in sorted(parameters): param_node = DefaultMutableTreeNode(parameter) vuln.add(param_node) self.vuln_tree.add(DefaultMutableTreeNode("Settings"))
def make_tree(self): root = DefaultMutableTreeNode(self.exper.name) for hseg in self.exper.hsegs(): hseg_node = DefaultMutableTreeNode(hseg.name) root.add(hseg_node) for file_suf in hseg.file_dict(): hseg_node.add(DefaultMutableTreeNode(file_suf)) self.tree = JTree(root) scrollPane = JScrollPane() scrollPane.getViewport().setView((self.tree)) # scrollPane.setPreferredSize(Dimension(300,250)) tree_panel = JPanel() tree_panel.add(scrollPane) box_layout = BoxLayout(self.panel, BoxLayout.Y_AXIS) self.panel.setLayout(box_layout) self.panel.add(tree_panel) self.revalidate()
def _add_nodes(self, curTop, dir): """ Recursive implementation to fill the tree with filenames and directories :param curTop: current top directory :param dir: next directory :return: None """ curPath = dir.getPath() if os.path.isdir(curPath): nodePath = os.path.basename(curPath) curDir = DefaultMutableTreeNode(nodePath) if curTop != None: # should only be null at root curTop.add(curDir) ol = Vector() tmp = dir.list() for i in xrange(0, len(tmp)): ol.addElement(tmp[i]) thisObject = None files = Vector() # Make two passes, one for Dirs and one for Files. This is #1. for i in xrange(0, ol.size()): thisObject = ol.elementAt(i) if curPath == self._dir: newPath = thisObject else: newPath = os.path.join(curPath, thisObject) f = File(newPath) if f.isDirectory(): self._add_nodes(curDir, f) else: files.addElement(thisObject) # Pass two: for files. Collections.sort(files) for i in xrange(0, files.size()): f = files.elementAt(i) #if f.split('.')[-1] != 'html': curDir.add(DefaultMutableTreeNode(files.elementAt(i))) return curDir
def cellTree(self): #----------------------------------------------------------------------- # Use the cellName as the tree root node #----------------------------------------------------------------------- cell = AdminConfig.list('Cell') cellName = self.getName(cell) root = DefaultMutableTreeNode(cellName) #----------------------------------------------------------------------- # Build an item name to configId dictionary #----------------------------------------------------------------------- result = {cellName: cell} #----------------------------------------------------------------------- # Use the node name for the branches #----------------------------------------------------------------------- for node in AdminConfig.list('Node').splitlines(): nodeName = self.getName(node) here = DefaultMutableTreeNode(nodeName) #------------------------------------------------------------------- # Add this node to the dictionary #------------------------------------------------------------------- result[nodeName] = node #------------------------------------------------------------------- # and the server name for each leaf #------------------------------------------------------------------- servers = AdminConfig.list('Server', node) for server in servers.splitlines(): name = self.getName(server) leaf = DefaultMutableTreeNode(name) #--------------------------------------------------------------- # Add this server to the dictionary # Note: Server names are not guaranteed to be unique in the cell #--------------------------------------------------------------- result[(nodeName, name)] = server here.add(leaf) root.add(here) return JTree(root), result
def __init__(self): mCitiesData = ['Memphis', 'Melbourne', 'Milan', 'Marrakech', 'Moscow', 'Munich'] sCitiesData = ['San Francisco', 'Salzburg', 'Santiago', 'Sydney', 'Sandnessjoen', 'Stockholm'] frame = JFrame("Jython JTree Example") frame.setSize(400, 350) frame.setLayout(BorderLayout()) root = DefaultMutableTreeNode('Cities') mCities = DefaultMutableTreeNode('Cities starting with M') sCities = DefaultMutableTreeNode('Cities starting with S') root.add(mCities) root.add(sCities) #now add the cities starting with M & S self.addCities(mCities, mCitiesData) self.addCities(sCities, sCitiesData) self.tree = JTree(root) scrollPane = JScrollPane() # add a scrollbar to the viewport scrollPane.setPreferredSize(Dimension(300,250)) scrollPane.getViewport().setView((self.tree)) panel = JPanel() panel.add(scrollPane) frame.add(panel, BorderLayout.CENTER) btn = JButton('Select', actionPerformed = self.citySelect) frame.add(btn,BorderLayout.SOUTH) self.label = JLabel('Select city') frame.add(self.label, BorderLayout.NORTH) frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE) frame.setVisible(True) self.addCities
def make_hseg_tree_panel(self): root = DefaultMutableTreeNode(self.exper.name) for hseg in self.exper.hsegs(): hseg_node = DefaultMutableTreeNode(hseg.name) root.add(hseg_node) hseg_at_deviations = self.exper.hseg_files_cab( ).archetype_deviations if len(hseg_at_deviations[hseg.name]) > 0: for definer, file_names in hseg_at_deviations[ hseg.name].items(): for file_name in file_names: node_str = definer + ': ' + file_name temp = DefaultMutableTreeNode(node_str) hseg_node.add(temp) hseg_tree = JTree(root) hseg_tree.setCellRenderer(BobPyTreeCellRenderer()) hseg_scroll_pane = JScrollPane() hseg_scroll_pane.getViewport().setView((hseg_tree)) hseg_panel = JPanel(MigLayout('insets 0')) hseg_panel.add(hseg_scroll_pane, 'grow, span, push, wrap') run_button = JButton('Run') run_button.addActionListener(ActionListenerFactory(self, self.run_al)) rerun_button = JButton('Rerun') rerun_button.addActionListener( ActionListenerFactory(self, self.rerun_al)) hseg_panel.add(run_button) hseg_panel.add(rerun_button) return hseg_panel
def make_hseg_tree_panel(self): root = DefaultMutableTreeNode(self.exper.name) for hseg in self.exper.hsegs(): hseg_node = DefaultMutableTreeNode(hseg.name) root.add(hseg_node) hseg_at_deviations = self.exper.hseg_all_files_cab( ).archetype_deviations if len(hseg_at_deviations[hseg.name]) > 0: for definer, file_names in hseg_at_deviations[ hseg.name].items(): for file_name in file_names: node_str = definer + ': ' + file_name temp = DefaultMutableTreeNode(node_str) hseg_node.add(temp) hseg_tree = JTree(root) hseg_tree.setCellRenderer(BobPyTreeCellRenderer()) hseg_scroll_pane = JScrollPane() hseg_scroll_pane.getViewport().setView((hseg_tree)) return hseg_scroll_pane
class View: def __init__(self): self.data = Data() self.checklist = self.data.get_checklist() self.issues = self.data.get_issues() self.set_checklist_tree() self.set_tree() self.set_pane() self.set_tabbed_panes() self.set_settings() self.set_tsl() def set_checklist(self, file_name): self.data.set_checklist(file_name) self.checklist = self.data.get_checklist() def get_checklist(self): return self.checklist def get_issues(self): return self.issues # TODO: Create the checklist dynamically for all nodes based on JSON structure # Creates a DefaultMutableTreeNode using the JSON file data def set_checklist_tree(self): self.checklist_tree = DefaultMutableTreeNode("HUNT - Methodology") for item in self.checklist: node = DefaultMutableTreeNode(item) self.checklist_tree.add(node) is_functionality = node.toString() == "Functionality" if is_functionality: functionality_node = node functionality = self.checklist["Functionality"] # TODO: Sort the functionality by name and by test name for functionality_name in functionality: tests = functionality[functionality_name]["tests"] node = DefaultMutableTreeNode(functionality_name) for test_name in tests: node.add(DefaultMutableTreeNode(test_name)) functionality_node.add(node) def get_checklist_tree(self): return self.checklist_tree # Creates a JTree object from the checklist def set_tree(self): self.tree = JTree(self.checklist_tree) self.tree.getSelectionModel().setSelectionMode( TreeSelectionModel.SINGLE_TREE_SELECTION) def get_tree(self): return self.tree # TODO: Change to briefcase icon for brief, P1-P5 icons for vulns, # bullseye icon for Targets, etc # Create a JSplitPlane with a JTree to the left and JTabbedPane to right def set_pane(self): status = JTextArea() status.setLineWrap(True) status.setText("Nothing selected") self.status = status self.pane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT, JScrollPane(self.tree), JTabbedPane()) self.pane.setDividerLocation(310) self.pane.getLeftComponent().setMinimumSize(Dimension(310, 300)) def get_pane(self): return self.pane # Creates the tabs dynamically using data from the JSON file def set_tabbed_panes(self): functionality = self.checklist["Functionality"] self.tabbed_panes = {} for functionality_name in functionality: tests = functionality[functionality_name]["tests"] for test_name in tests: key = functionality_name + "." + test_name tabbed_pane = self.set_tabbed_pane(functionality_name, test_name) self.tabbed_panes[key] = self.tabbed_pane def get_tabbed_panes(self): return self.tabbed_panes # Creates a JTabbedPane for each vulnerability per functionality def set_tabbed_pane(self, functionality_name, test_name): description_tab = self.set_description_tab(functionality_name, test_name) bugs_tab = self.set_bugs_tab() resources_tab = self.set_resource_tab(functionality_name, test_name) notes_tab = self.set_notes_tab() self.tabbed_pane = JTabbedPane() self.tabbed_pane.add("Description", description_tab) self.tabbed_pane.add("Bugs", bugs_tab) self.tabbed_pane.add("Resources", resources_tab) self.tabbed_pane.add("Notes", notes_tab) # Creates the description panel def set_description_tab(self, fn, vn): description_text = str( self.checklist["Functionality"][fn]["tests"][vn]["description"]) description_textarea = JTextArea() description_textarea.setLineWrap(True) description_textarea.setText(description_text) description_panel = JScrollPane(description_textarea) return description_panel # TODO: Add functionality to remove tabs # Creates the bugs panel def set_bugs_tab(self): bugs_tab = JTabbedPane() return bugs_tab # Creates the resources panel def set_resource_tab(self, fn, vn): resource_urls = self.checklist["Functionality"][fn]["tests"][vn][ "resources"] resource_text = "" for url in resource_urls: resource_text = resource_text + str(url) + "\n" resource_textarea = JTextArea() resource_textarea.setLineWrap(True) resource_textarea.setWrapStyleWord(True) resource_textarea.setText(resource_text) resources_panel = JScrollPane(resource_textarea) return resources_panel def set_notes_tab(self): notes_textarea = JTextArea() return notes_textarea def set_tsl(self): self.tsl = TSL(self) self.tree.addTreeSelectionListener(self.tsl) return def get_tsl(self): return self.tsl def set_settings(self): self.settings = JPanel() layout = GroupLayout(self.settings) self.settings.setLayout(layout) layout.setAutoCreateGaps(True) load_file_button = JButton("Load JSON File") load_file_button.setActionCommand("load") load_file_button.addActionListener( SettingsAction(self, load_file_button, None)) save_file_button = JButton("Save JSON File") save_file_button.setActionCommand("save") save_file_button.addActionListener( SettingsAction(None, save_file_button, self.tabbed_panes)) horizontal_group1 = layout.createParallelGroup( GroupLayout.Alignment.LEADING) horizontal_group1.addComponent(load_file_button) horizontal_group1.addComponent(save_file_button) horizontal_group = layout.createSequentialGroup() horizontal_group.addGroup(horizontal_group1) layout.setHorizontalGroup(horizontal_group) vertical_group1 = layout.createParallelGroup( GroupLayout.Alignment.BASELINE) vertical_group1.addComponent(load_file_button) vertical_group2 = layout.createParallelGroup( GroupLayout.Alignment.BASELINE) vertical_group2.addComponent(save_file_button) vertical_group = layout.createSequentialGroup() vertical_group.addGroup(vertical_group1) vertical_group.addGroup(vertical_group2) layout.setVerticalGroup(vertical_group) def get_settings(self): return self.settings def set_request_tab_pane(self, request_response): raw_request = request_response.getRequest() request_body = StringUtil.fromBytes(raw_request) request_body = request_body.encode("utf-8") request_tab_textarea = JTextArea(request_body) request_tab_textarea.setLineWrap(True) return JScrollPane(request_tab_textarea) def set_response_tab_pane(self, request_response): raw_response = request_response.getResponse() response_body = StringUtil.fromBytes(raw_response) response_body = response_body.encode("utf-8") response_tab_textarea = JTextArea(response_body) response_tab_textarea.setLineWrap(True) return JScrollPane(response_tab_textarea) def set_bugs_tabbed_pane(self, request_tab, response_tab): bugs_tabbed_pane = JTabbedPane() bugs_tabbed_pane.add("Request", request_tab) bugs_tabbed_pane.add("Response", response_tab) return bugs_tabbed_pane
class View: def __init__(self, issues): self.json = issues.get_json() self.issues_object = issues self.issues = issues.get_issues() self.scanner_issues = issues.get_scanner_issues() self.scanner_panes = {} self.scanner_table_models = {} self.scanner_tables = {} self.is_scanner_panes = [] self.set_vuln_tree() self.set_tree() self.set_scanner_table_models() self.set_scanner_panes() self.set_pane() self.set_settings() self.set_tsl() def get_issues_object(self): return self.issues_object def set_callbacks(self, callbacks): self.callbacks = callbacks def set_helpers(self, helpers): self.helpers = helpers def get_helpers(self): return self.helpers def get_issues(self): return self.issues def get_scanner_issues(self): return self.scanner_issues def set_is_scanner_pane(self, scanner_pane): self.is_scanner_panes.append(scanner_pane) def get_is_scanner_pane(self, scanner_pane): for pane in self.get_is_scanner_panes(): if pane == scanner_pane: return True return False def get_is_scanner_panes(self): return self.is_scanner_panes def set_vuln_tree(self): self.vuln_tree = DefaultMutableTreeNode("HUNT Scanner") vulns = self.json["issues"] # TODO: Sort the functionality by name and by vuln class for vuln_name in sorted(vulns): vuln = DefaultMutableTreeNode(vuln_name) self.vuln_tree.add(vuln) parameters = self.json["issues"][vuln_name]["params"] for parameter in sorted(parameters): param_node = DefaultMutableTreeNode(parameter) vuln.add(param_node) self.vuln_tree.add(DefaultMutableTreeNode("Settings")) # Creates a JTree object from the checklist def set_tree(self): self.tree = JTree(self.vuln_tree) self.tree.getSelectionModel().setSelectionMode( TreeSelectionModel.SINGLE_TREE_SELECTION) def get_tree(self): return self.tree def set_scanner_table_models(self): issues = self.issues for issue in issues: issue_name = issue["name"] issue_param = issue["param"] self.create_scanner_table_model(issue_name, issue_param) # Creates the tabs dynamically using data from the JSON file def set_scanner_panes(self): for issue in self.issues: issue_name = issue["name"] issue_param = issue["param"] key = issue_name + "." + issue_param top_pane = self.create_request_list_pane(issue_name) bottom_pane = self.create_tabbed_pane() scanner_pane = JSplitPane(JSplitPane.VERTICAL_SPLIT, top_pane, bottom_pane) self.scanner_panes[key] = scanner_pane def get_scanner_panes(self): return self.scanner_panes def create_request_list_pane(self, issue_name): request_list_pane = JScrollPane() return request_list_pane # Creates a JTabbedPane for each vulnerability per functionality def create_tabbed_pane(self): tabbed_pane = JTabbedPane() tabbed_pane.add("Advisory", JScrollPane()) tabbed_pane.add("Request", JScrollPane()) tabbed_pane.add("Response", JScrollPane()) self.tabbed_pane = tabbed_pane return tabbed_pane def get_settings(self): return self.settings def set_settings(self): self.settings = JPanel() layout = GroupLayout(self.settings) self.settings.setLayout(layout) layout.setAutoCreateGaps(True) load_file_button = JButton("Load JSON File") load_file_button.setActionCommand("load") load_file_button.addActionListener( SettingsAction(self, load_file_button, None)) save_file_button = JButton("Save JSON File") save_file_button.setActionCommand("save") save_file_button.addActionListener( SettingsAction(self, save_file_button, self.scanner_panes)) horizontal_group1 = layout.createParallelGroup( GroupLayout.Alignment.LEADING) horizontal_group1.addComponent(load_file_button) horizontal_group1.addComponent(save_file_button) horizontal_group = layout.createSequentialGroup() horizontal_group.addGroup(horizontal_group1) layout.setHorizontalGroup(horizontal_group) vertical_group1 = layout.createParallelGroup( GroupLayout.Alignment.BASELINE) vertical_group1.addComponent(load_file_button) vertical_group2 = layout.createParallelGroup( GroupLayout.Alignment.BASELINE) vertical_group2.addComponent(save_file_button) vertical_group = layout.createSequentialGroup() vertical_group.addGroup(vertical_group1) vertical_group.addGroup(vertical_group2) layout.setVerticalGroup(vertical_group) def set_tsl(self): tsl = TSL(self) self.tree.addTreeSelectionListener(tsl) return def set_pane(self): status = JTextArea() status.setLineWrap(True) status.setText("Nothing selected") self.status = status request_list_pane = JScrollPane() scanner_pane = JSplitPane(JSplitPane.VERTICAL_SPLIT, request_list_pane, self.tabbed_pane) self.pane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT, JScrollPane(self.tree), scanner_pane) self.pane.setDividerLocation(310) self.pane.getLeftComponent().setMinimumSize(Dimension(310, 300)) def get_pane(self): return self.pane # TODO: Move all scanner table functions into its own ScannerTable class # as well as ScannerTableModel for all scanner table model functions def create_scanner_table_model(self, issue_name, issue_param): key = issue_name + "." + issue_param is_model_exists = key in self.scanner_table_models if is_model_exists: return scanner_table_model = ScannerTableModel() scanner_table_model.addColumn("") scanner_table_model.addColumn("Parameter") scanner_table_model.addColumn("Host") scanner_table_model.addColumn("Path") scanner_table_model.addColumn("ID") self.scanner_table_models[key] = scanner_table_model def set_scanner_table_model(self, scanner_issue, issue_name, issue_param, vuln_param): key = issue_name + "." + vuln_param scanner_issue_id = str( scanner_issue.getRequestResponse()).split("@")[1] scanner_table_model = self.scanner_table_models[key] # Using the addRow() method requires that the data type being passed to be of type # Vector() or Object(). Passing a Python object of type list in addRow causes a type # conversion error of sorts which presents as an ArrayOutOfBoundsException. Therefore, # row is an instantiation of Object() to avoid this error. row = Object() row = [ False, issue_param, scanner_issue.getHttpService().getHost(), scanner_issue.getPath(), scanner_issue_id ] scanner_table_model.addRow(row) # Wait for ScannerTableModel to update as to not get an ArrayOutOfBoundsException. Thread.sleep(500) scanner_table_model.fireTableDataChanged() scanner_table_model.fireTableStructureChanged() def get_scanner_table_model(self, issue_name, issue_param): key = issue_name + "." + issue_param return self.scanner_table_models[key] def set_scanner_pane(self, scanner_pane, issue_name, issue_param): key = issue_name + "." + issue_param request_table_pane = scanner_pane.getTopComponent() if key in self.scanner_tables: scanner_table = self.scanner_tables[key] else: scanner_table = self.create_scanner_table(scanner_pane, issue_name, issue_param) self.scanner_tables[key] = scanner_table request_table_pane.getViewport().setView(scanner_table) request_table_pane.revalidate() request_table_pane.repaint() def create_scanner_table(self, scanner_pane, issue_name, issue_param): scanner_table_model = self.get_scanner_table_model( issue_name, issue_param) scanner_table = JTable(scanner_table_model) scanner_table.getColumnModel().getColumn(0).setMaxWidth(10) scanner_table.putClientProperty("terminateEditOnFocusLost", True) scanner_table_listener = ScannerTableListener(self, scanner_table, issue_name, issue_param) scanner_table_model.addTableModelListener(scanner_table_listener) scanner_table_list_listener = IssueListener(self, scanner_table, scanner_pane, issue_name, issue_param) scanner_table.getSelectionModel().addListSelectionListener( scanner_table_list_listener) return scanner_table # Takes into account if there are more than one scanner issues that share the same hostname, path, name, param, and id def set_tabbed_pane(self, scanner_pane, request_list, issue_hostname, issue_path, issue_name, issue_param, scanner_issue_id): tabbed_pane = scanner_pane.getBottomComponent() scanner_issues = self.get_scanner_issues() current_issue = self.set_current_issue(scanner_issues, issue_hostname, issue_path, issue_name, issue_param, scanner_issue_id) advisory_tab_pane = self.set_advisory_tab_pane(current_issue) tabbed_pane.setComponentAt(0, advisory_tab_pane) request_tab_pane = self.set_request_tab_pane(current_issue) tabbed_pane.setComponentAt(1, request_tab_pane) response_tab_pane = self.set_response_tab_pane(current_issue) tabbed_pane.setComponentAt(2, response_tab_pane) def set_current_issue(self, scanner_issues, issue_hostname, issue_path, issue_name, issue_param, scanner_issue_id): for scanner_issue in scanner_issues: is_same_hostname = scanner_issue.getHostname() == issue_hostname is_same_path = scanner_issue.getPath() == issue_path is_same_name = scanner_issue.getIssueName() == issue_name is_same_param = scanner_issue.getParameter() == issue_param is_same_id = str(scanner_issue.getRequestResponse()).split( "@")[1] == scanner_issue_id is_same_issue = is_same_hostname and is_same_path and is_same_name and is_same_param and is_same_id if is_same_issue: return scanner_issue def set_advisory_tab_pane(self, scanner_issue): advisory_pane = JEditorPane() advisory_pane.setEditable(False) advisory_pane.setEnabled(True) advisory_pane.setContentType("text/html") link_listener = LinkListener() advisory_pane.addHyperlinkListener(link_listener) advisory = "<html><b>Location</b>: {}<br><br>{}</html>" advisory_pane.setText( advisory.format(scanner_issue.getUrl().encode("utf-8"), scanner_issue.getIssueDetail())) return JScrollPane(advisory_pane) def set_request_tab_pane(self, scanner_issue): request_response = scanner_issue.getRequestResponse() controller = MessageController(request_response) message_editor = self.callbacks.createMessageEditor(controller, True) message_editor.setMessage(request_response.getRequest(), True) component = message_editor.getComponent() return component def set_response_tab_pane(self, scanner_issue): request_response = scanner_issue.getRequestResponse() controller = MessageController(request_response) message_editor = self.callbacks.createMessageEditor(controller, True) message_editor.setMessage(request_response.getResponse(), False) component = message_editor.getComponent() return component def traverse_tree(self, tree, model, issue_name, issue_param, issue_count, total_count): root = model.getRoot() count = int(root.getChildCount()) traverse = {} for i in range(count): node = model.getChild(root, i) traverse["node"] = node tree_issue_name = node.toString() is_issue_name = re.search(issue_name, tree_issue_name) if is_issue_name: child_count = node.getChildCount() for j in range(child_count): child = node.getChildAt(j) traverse["child"] = child tree_param_name = child.toString() is_param_name = re.search(issue_param, tree_param_name) if is_param_name: traverse["param_text"] = issue_param + " (" + str( issue_count) + ")" break traverse["issue_text"] = issue_name + " (" + str( total_count) + ")" break return traverse def set_scanner_count(self, issue_name, issue_param, issue_count, total_count): tree = self.get_tree() model = tree.getModel() traverse = self.traverse_tree(tree, model, issue_name, issue_param, issue_count, total_count) node = traverse["node"] child = traverse["child"] child.setUserObject(traverse["param_text"]) model.nodeChanged(child) model.reload(node) node.setUserObject(traverse["issue_text"]) model.nodeChanged(node) model.reload(node)
class View: def __init__(self, issues): self.json = issues.get_json() self.issues_object = issues self.issues = issues.get_issues() self.scanner_issues = issues.get_scanner_issues() self.scanner_panes = {} self.scanner_tables = {} self.is_scanner_panes = [] self.set_vuln_tree() self.set_tree() self.set_scanner_panes() self.set_pane() self.set_tsl() def set_callbacks(self, callbacks): self.callbacks = callbacks def set_helpers(self, helpers): self.helpers = helpers def get_helpers(self): return self.helpers def get_issues(self): return self.issues def get_scanner_issues(self): return self.scanner_issues def set_scanner_count(self, is_checked, issue_name, issue_param): self.issues_object.set_scanner_count(self, is_checked, issue_name, issue_param) def set_is_scanner_pane(self, scanner_pane): self.is_scanner_panes.append(scanner_pane) def get_is_scanner_pane(self, scanner_pane): for pane in self.get_is_scanner_panes(): if pane == scanner_pane: return True return False def get_is_scanner_panes(self): return self.is_scanner_panes def set_vuln_tree(self): self.vuln_tree = DefaultMutableTreeNode("Vulnerability Classes") vulns = self.json["issues"] # TODO: Sort the functionality by name and by vuln class for vuln_name in vulns: vuln = DefaultMutableTreeNode(vuln_name) self.vuln_tree.add(vuln) parameters = self.json["issues"][vuln_name]["params"] for parameter in parameters: param_node = DefaultMutableTreeNode(parameter) vuln.add(param_node) # Creates a JTree object from the checklist def set_tree(self): self.tree = JTree(self.vuln_tree) self.tree.getSelectionModel().setSelectionMode( TreeSelectionModel.SINGLE_TREE_SELECTION ) def get_tree(self): return self.tree # Creates the tabs dynamically using data from the JSON file def set_scanner_panes(self): issues = self.issues for issue in issues: issue_name = issue["name"] issue_param = issue["param"] key = issue_name + "." + issue_param top_pane = self.create_request_list_pane(issue_name) bottom_pane = self.create_tabbed_pane() scanner_pane = JSplitPane(JSplitPane.VERTICAL_SPLIT, top_pane, bottom_pane) self.scanner_panes[key] = scanner_pane def get_scanner_panes(self): return self.scanner_panes def create_request_list_pane(self, issue_name): request_list_pane = JScrollPane() return request_list_pane # Creates a JTabbedPane for each vulnerability per functionality def create_tabbed_pane(self): tabbed_pane = JTabbedPane() tabbed_pane.add("Advisory", JScrollPane()) tabbed_pane.add("Request", JScrollPane()) tabbed_pane.add("Response", JScrollPane()) self.tabbed_pane = tabbed_pane return tabbed_pane def set_tsl(self): tsl = TSL(self) self.tree.addTreeSelectionListener(tsl) return def set_pane(self): status = JTextArea() status.setLineWrap(True) status.setText("Nothing selected") self.status = status request_list_pane = JScrollPane() scanner_pane = JSplitPane(JSplitPane.VERTICAL_SPLIT, request_list_pane, self.tabbed_pane ) self.pane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT, JScrollPane(self.tree), scanner_pane ) self.pane.setDividerLocation(310) self.pane.getLeftComponent().setMinimumSize(Dimension(310, 300)) def get_pane(self): return self.pane def set_scanner_table(self, scanner_pane, scanner_table): self.scanner_tables[scanner_pane] = scanner_table def get_scanner_table(self, scanner_pane): return self.scanner_tables[scanner_pane] def set_scanner_pane(self, scanner_pane): request_table_pane = scanner_pane.getTopComponent() scanner_table = self.get_scanner_table(scanner_pane) request_table_pane.getViewport().setView(scanner_table) request_table_pane.revalidate() request_table_pane.repaint() def create_scanner_pane(self, scanner_pane, issue_name, issue_param): scanner_issues = self.get_scanner_issues() request_table_pane = scanner_pane.getTopComponent() scanner_table_model = ScannerTableModel() scanner_table_model.addColumn("Checked") scanner_table_model.addColumn("Host") scanner_table_model.addColumn("Path") # Search all issues for the correct issue. Once found, add it into # the scanner table model to be showed in the UI. for scanner_issue in scanner_issues: is_same_name = scanner_issue.getIssueName() == issue_name is_same_param = scanner_issue.getParameter() == issue_param is_same_issue = is_same_name and is_same_param if is_same_issue: scanner_table_model.addRow([ False, scanner_issue.getHttpService().getHost(), scanner_issue.getUrl() ]) scanner_table = JTable(scanner_table_model) scanner_table.getColumnModel().getColumn(0).setCellEditor(DefaultCellEditor(JCheckBox())) scanner_table.putClientProperty("terminateEditOnFocusLost", True) scanner_table_listener = ScannerTableListener(self, scanner_table, issue_name, issue_param) scanner_table_model.addTableModelListener(scanner_table_listener) scanner_table_list_listener = IssueListener(self, scanner_table, scanner_pane, issue_name, issue_param) scanner_table.getSelectionModel().addListSelectionListener(scanner_table_list_listener) self.set_scanner_table(scanner_pane, scanner_table) request_table_pane.getViewport().setView(scanner_table) request_table_pane.revalidate() request_table_pane.repaint() def set_tabbed_pane(self, scanner_pane, request_list, issue_url, issue_name, issue_param): tabbed_pane = scanner_pane.getBottomComponent() scanner_issues = self.get_scanner_issues() for scanner_issue in scanner_issues: is_same_url = scanner_issue.getUrl() == issue_url is_same_name = scanner_issue.getIssueName() == issue_name is_same_param = scanner_issue.getParameter() == issue_param is_same_issue = is_same_url and is_same_name and is_same_param if is_same_issue: current_issue = scanner_issue self.set_context_menu(request_list, scanner_issue) break advisory_tab_pane = self.set_advisory_tab_pane(current_issue) tabbed_pane.setComponentAt(0, advisory_tab_pane) request_tab_pane = self.set_request_tab_pane(current_issue) tabbed_pane.setComponentAt(1, request_tab_pane) response_tab_pane = self.set_response_tab_pane(current_issue) tabbed_pane.setComponentAt(2, response_tab_pane) def set_advisory_tab_pane(self, scanner_issue): advisory_pane = JEditorPane() advisory_pane.setEditable(False) advisory_pane.setEnabled(True) advisory_pane.setContentType("text/html") link_listener = LinkListener() advisory_pane.addHyperlinkListener(link_listener) advisory_pane.setText("<html>" + "<b>Location</b>: " + scanner_issue.getUrl() + "<br><br>" + scanner_issue.getIssueDetail() + "</html>" ) # Set a context menu self.set_context_menu(advisory_pane, scanner_issue) return JScrollPane(advisory_pane) def set_request_tab_pane(self, scanner_issue): raw_request = scanner_issue.getRequestResponse().getRequest() request_body = StringUtil.fromBytes(raw_request) request_body = request_body.encode("utf-8") request_tab_textarea = JTextArea(request_body) request_tab_textarea.setLineWrap(True) # Set a context menu self.set_context_menu(request_tab_textarea, scanner_issue) return JScrollPane(request_tab_textarea) def set_response_tab_pane(self, scanner_issue): raw_response = scanner_issue.getRequestResponse().getResponse() response_body = StringUtil.fromBytes(raw_response) response_body = response_body.encode("utf-8") response_tab_textarea = JTextArea(response_body) response_tab_textarea.setLineWrap(True) # Set a context menu self.set_context_menu(response_tab_textarea, scanner_issue) return JScrollPane(response_tab_textarea) # Pass scanner_issue as argument def set_context_menu(self, component, scanner_issue): self.context_menu = JPopupMenu() repeater = JMenuItem("Send to Repeater") repeater.addActionListener(PopupListener(scanner_issue, self.callbacks)) intruder = JMenuItem("Send to Intruder") intruder.addActionListener(PopupListener(scanner_issue, self.callbacks)) hunt = JMenuItem("Send to HUNT") self.context_menu.add(repeater) self.context_menu.add(intruder) context_menu_listener = ContextMenuListener(component, self.context_menu) component.addMouseListener(context_menu_listener) def get_context_menu(self): return self.context_menu
def createNewModel(): root = DefaultMutableTreeNode("Root") vegetableNode = DefaultMutableTreeNode("Vegetables") vegetableNode.add(DefaultMutableTreeNode("Capsicum")) vegetableNode.add(DefaultMutableTreeNode("Carrot")) vegetableNode.add(DefaultMutableTreeNode("Tomato")) fruitNode = DefaultMutableTreeNode("Fruits") fruitNode.add(DefaultMutableTreeNode("Grapes")) fruitNode.add(DefaultMutableTreeNode("Orange")) color = DefaultMutableTreeNode("Colors") color.add(DefaultMutableTreeNode("Orange")) color.add(DefaultMutableTreeNode("Red")) fruitNode.add(color) root.add(vegetableNode) root.add(fruitNode) #printNode(root) model = DefaultTreeModel(root) return model
def cellTree(self, data): #----------------------------------------------------------------------- # Use the cellName as the tree root node #----------------------------------------------------------------------- cell = AdminConfig.list('Cell') cellName = self.getName(cell) #----------------------------------------------------------------------- # Note: data is the one and only instance of the inner cellInfo class #----------------------------------------------------------------------- data.addInfoValue( cellName, CELLINFO % (cellName, WAShome(cell), WASversion(cell), WASprofileName(cell))) root = DefaultMutableTreeNode(cellName) #----------------------------------------------------------------------- # Build an item name to configId dictionary #----------------------------------------------------------------------- result = {cellName: cell} #----------------------------------------------------------------------- # Use the node name for the branches #----------------------------------------------------------------------- for node in AdminConfig.list('Node').splitlines(): nodeName = self.getName(node) here = DefaultMutableTreeNode(nodeName) #------------------------------------------------------------------- # Add this node to the dictionary #------------------------------------------------------------------- result[nodeName] = node #------------------------------------------------------------------- # and the server name for each leaf #------------------------------------------------------------------- servers = AdminConfig.list('Server', node) for server in servers.splitlines(): servName = self.getName(server) leaf = DefaultMutableTreeNode(servName) #--------------------------------------------------------------- # Add this server to the dictionary # Note: Server names are not guaranteed to be unique in the cell #--------------------------------------------------------------- result[(nodeName, servName)] = server here.add(leaf) hostnames = getHostnames(nodeName, servName) ipaddr = getIPaddresses(hostnames) data.addInfoValue( nodeName, NODEINFO % (cellName, nodeName, WAShome(node), WASversion(node), WASprofileName(node), ', '.join(hostnames), ', '.join(ipaddr))) PortLookupTask(nodeName, servName, data).execute() root.add(here) #----------------------------------------------------------------------- # Note: data is the one and only instance of the inner cellInfo class #----------------------------------------------------------------------- data.setNames(result) return JTree(root)