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)
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 PTTextField(JPanel):
def getName(self):
return self._name
def setText(self, text):
self._textfield.setText(text)
def getText(self):
return self._textfield.getText()
def __init__(self, name, label, text, function=None, button1=None, button2=None):
length = 1000
self._name = name
self._label = JLabel(label)
self._textfield = JTextField(length) \
if function is None \
else JTextField(length, actionPerformed=function)
self.add(self._label)
self.add(self._textfield)
if button1 is not None:
self._button1 = button1
self.add(self._button1)
if button2 is not None:
self._button2 = button2
self.add(self._button2)
self.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5))
self._textfield.setText("0" * length)
self._textfield.setMaximumSize(self._textfield.getPreferredSize())
self.setMaximumSize(self.getPreferredSize())
self.setText(text)
self.setLayout(BoxLayout(self, BoxLayout.X_AXIS))
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())
))
class ConversationWindow(Conversation):
"""A GUI window of a conversation with a specific person"""
def __init__(self, person, chatui):
"""ConversationWindow(basesupport.AbstractPerson:person)"""
Conversation.__init__(self, person, chatui)
self.mainframe = JFrame("Conversation with "+person.name)
self.display = JTextArea(columns=100,
rows=15,
editable=0,
lineWrap=1)
self.typepad = JTextField()
self.buildpane()
self.lentext = 0
def buildpane(self):
buttons = JPanel(doublebuffered)
buttons.add(JButton("Send", actionPerformed=self.send))
buttons.add(JButton("Hide", actionPerformed=self.hidewindow))
mainpane = self.mainframe.getContentPane()
mainpane.setLayout(BoxLayout(mainpane, BoxLayout.Y_AXIS))
mainpane.add(JScrollPane(self.display))
self.typepad.actionPerformed = self.send
mainpane.add(self.typepad)
mainpane.add(buttons)
def show(self):
self.mainframe.pack()
self.mainframe.show()
def hide(self):
self.mainframe.hide()
def sendText(self, text):
self.displayText("\n"+self.person.client.name+": "+text)
Conversation.sendText(self, text)
def showMessage(self, text, metadata=None):
self.displayText("\n"+self.person.name+": "+text)
def contactChangedNick(self, person, newnick):
Conversation.contactChangedNick(self, person, newnick)
self.mainframe.setTitle("Conversation with "+newnick)
#GUI code
def displayText(self, text):
self.lentext = self.lentext + len(text)
self.display.append(text)
self.display.setCaretPosition(self.lentext)
#actionlisteners
def hidewindow(self, ae):
self.hide()
def send(self, ae):
text = self.typepad.getText()
self.typepad.setText("")
if text != "" and text != None:
self.sendText(text)
class HumanDetailPanel(DetailPanel):
""" generated source for class HumanDetailPanel """
moveTable = JZebraTable()
moveTextField = JTextField()
selectButton = JButton()
selection = Move()
timerBar = JTimerBar()
def __init__(self):
""" generated source for method __init__ """
super(HumanDetailPanel, self).__init__(GridBagLayout())
model = DefaultTableModel()
model.addColumn("Legal Moves")
self.moveTable = JZebraTable(model)
self.selectButton = JButton(selectButtonMethod())
self.moveTextField = JTextField()
self.timerBar = JTimerBar()
self.selection = None
self.moveTable.setShowHorizontalLines(True)
self.moveTable.setShowVerticalLines(True)
self.moveTextField.setEditable(False)
self.add(JScrollPane(self.moveTable, ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED), GridBagConstraints(0, 0, 2, 1, 1.0, 1.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, Insets(5, 5, 5, 5), 5, 5))
self.add(self.selectButton, GridBagConstraints(0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.HORIZONTAL, Insets(5, 5, 5, 5), 0, 0))
self.add(self.moveTextField, GridBagConstraints(1, 1, 1, 1, 1.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, Insets(5, 5, 5, 5), 5, 5))
self.add(self.timerBar, GridBagConstraints(0, 2, 2, 1, 1.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, Insets(5, 5, 5, 5), 5, 5))
@overloaded
def observe(self, event):
""" generated source for method observe """
if isinstance(event, (HumanNewMovesEvent, )):
self.observe(event)
elif isinstance(event, (HumanTimeoutEvent, )):
self.observe(event)
elif isinstance(event, (PlayerTimeEvent, )):
self.observe(event)
@observe.register(object, HumanNewMovesEvent)
def observe_0(self, event):
""" generated source for method observe_0 """
model = self.moveTable.getModel()
model.setRowCount(0)
for move in event.getMoves():
model.addRow([None]*)
self.selection = event.getSelection()
self.moveTextField.setText(self.selection.__str__())
@observe.register(object, HumanTimeoutEvent)
def observe_1(self, event):
""" generated source for method observe_1 """
event.getHumanPlayer().setMove(self.selection)
@observe.register(object, PlayerTimeEvent)
def observe_2(self, event):
""" generated source for method observe_2 """
self.timerBar.time(event.getTime(), 500)
def selectButtonMethod(self):
""" generated source for method selectButtonMethod """
return AbstractAction("Select")
class PrefsPanel(JPanel):
"""JPanle with gui for tool preferences
"""
def __init__(self, app):
strings = app.strings
self.setLayout(GridLayout(3, 2, 5, 5))
userLbl = JLabel(strings.getString("osmose_pref_username"))
self.userTextField = JTextField(20)
self.userTextField.setToolTipText(
strings.getString("osmose_pref_username_tooltip"))
levelLbl = JLabel(strings.getString("osmose_pref_level"))
self.levels = ["1", "1,2", "1,2,3", "2", "3"]
self.levelsCombo = JComboBox(self.levels)
self.levelsCombo.setToolTipText(
strings.getString("osmose_pref_level_tooltip"))
limitLbl = JLabel(strings.getString("osmose_pref_limit"))
self.limitTextField = JTextField(20)
self.limitTextField.setToolTipText(
strings.getString("osmose_pref_limit_tooltip"))
self.add(userLbl)
self.add(self.userTextField)
self.add(levelLbl)
self.add(self.levelsCombo)
self.add(limitLbl)
self.add(self.limitTextField)
def update_gui(self, preferences):
"""Update preferences gui
"""
self.userTextField.setText(preferences["username"])
self.levelsCombo.setSelectedIndex(
self.levels.index(preferences["level"]))
self.limitTextField.setText(str(preferences["limit"]))
def read_gui(self):
"""Read preferences from gui
"""
username = self.userTextField.getText()
level = self.levelsCombo.getSelectedItem()
limit = self.limitTextField.getText()
try:
limit = Integer.parseInt(limit)
if limit > 500:
limit = 500
limit = str(limit)
except NumberFormatException:
limit = ""
preferences = {
"username": username.strip(),
"level": level,
"limit": limit
}
return preferences
class ConversationWindow(Conversation):
"""A GUI window of a conversation with a specific person"""
def __init__(self, person, chatui):
"""ConversationWindow(basesupport.AbstractPerson:person)"""
Conversation.__init__(self, person, chatui)
self.mainframe = JFrame("Conversation with " + person.name)
self.display = JTextArea(columns=100, rows=15, editable=0, lineWrap=1)
self.typepad = JTextField()
self.buildpane()
self.lentext = 0
def buildpane(self):
buttons = JPanel(doublebuffered)
buttons.add(JButton("Send", actionPerformed=self.send))
buttons.add(JButton("Hide", actionPerformed=self.hidewindow))
mainpane = self.mainframe.getContentPane()
mainpane.setLayout(BoxLayout(mainpane, BoxLayout.Y_AXIS))
mainpane.add(JScrollPane(self.display))
self.typepad.actionPerformed = self.send
mainpane.add(self.typepad)
mainpane.add(buttons)
def show(self):
self.mainframe.pack()
self.mainframe.show()
def hide(self):
self.mainframe.hide()
def sendText(self, text):
self.displayText("\n" + self.person.client.name + ": " + text)
Conversation.sendText(self, text)
def showMessage(self, text, metadata=None):
self.displayText("\n" + self.person.name + ": " + text)
def contactChangedNick(self, person, newnick):
Conversation.contactChangedNick(self, person, newnick)
self.mainframe.setTitle("Conversation with " + newnick)
#GUI code
def displayText(self, text):
self.lentext = self.lentext + len(text)
self.display.append(text)
self.display.setCaretPosition(self.lentext)
#actionlisteners
def hidewindow(self, ae):
self.hide()
def send(self, ae):
text = self.typepad.getText()
self.typepad.setText("")
if text != "" and text != None:
self.sendText(text)
def makeUI(model):
# Components:
table = JTable(model)
jsp = JScrollPane(table)
regex_label = JLabel("Search: ")
regex_field = JTextField(20)
base_path_label = JLabel("Base path:")
base_path_field = JTextField(50)
if base_path is not None:
base_path_field.setText(base_path)
# Panel for all components
all = JPanel()
all.setBorder(EmptyBorder(20, 20, 20, 20))
layout, c = GridBagLayout(), GC()
all.setLayout(layout)
# First row: label and regex text field
add(all, regex_label, gridx=0, gridy=0) # with default constraints
add(all, regex_field, gridx=1, gridy=0, fill=GC.HORIZONTAL, weightx=1.0)
# Second row: the table
add(all,
jsp,
gridx=0,
gridy=1,
fill=GC.BOTH,
gridwidth=2,
weightx=1.0,
weighty=1.0) # full weights so it stretches when resizing
# Third row: the base path
add(all, base_path_label, gridx=0, gridy=2)
add(all,
base_path_field,
gridx=1,
gridy=2,
fill=GC.HORIZONTAL,
weightx=1.0)
# Window frame
frame = JFrame("File paths")
frame.getContentPane().add(all)
#frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
frame.addWindowListener(Closing())
frame.pack()
frame.setVisible(True)
# Listeners
regex_field.addKeyListener(EnterListener(table))
table.addMouseListener(RowClickListener(base_path_field))
al = ArrowListener(table, regex_field)
table.addKeyListener(al)
regex_field.addKeyListener(al)
# Instead of a KeyListener, use the input vs action map
table.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0),
"enter")
table.getActionMap().put("enter", OpenImageFromTableCell())
#
return model, table, regex_field, frame
class consoleTimeout1( java.lang.Runnable ) :
#---------------------------------------------------------------------------
# Name: run()
# Role: Build and display our graphical application
# Note: Invoked by the Swing Event Dispatch Thread
#---------------------------------------------------------------------------
def run( self ) :
frame = JFrame(
'Console timeout',
defaultCloseOperation = JFrame.EXIT_ON_CLOSE
)
#-----------------------------------------------------------------------
# The frame (i.e., it's ContentPane) should use a vertically aligned
# BoxLayout layout manager (i.e., along the Y_AXIS)
#-----------------------------------------------------------------------
cp = frame.getContentPane()
cp.setLayout( BoxLayout( cp, BoxLayout.Y_AXIS ) )
#-----------------------------------------------------------------------
# The JTextField will be preceeded, and followed by JLabel components
# identifying the value being displayed, and the associated time units.
# However, we want them displayed horizontally, so we put them into a
# single JPanel instance using a FlowLayout layout manager
#-----------------------------------------------------------------------
input = JPanel( layout = FlowLayout() )
input.add( JLabel( 'Timeout:' ) )
self.text = JTextField( 3, actionPerformed = self.update )
input.add( self.text )
self.text.setText( getTimeout() )
input.add( JLabel( 'minutes' ) )
cp.add( input )
#-----------------------------------------------------------------------
# Then, we add a message area beneath
#-----------------------------------------------------------------------
self.msg = cp.add( JLabel() )
frame.setSize( 290, 100 )
frame.setVisible( 1 )
#---------------------------------------------------------------------------
# Name: update()
# Role: TextField event handler - invoked when user presses <Enter>
#---------------------------------------------------------------------------
def update( self, event ) :
value = self.text.getText().strip()
if re.search( '^\d+$', value ) :
self.msg.setText( setTimeout( value ) )
else :
msg = 'Invalid value "%s" ignored.' % value
self.msg.setText( msg )
self.text.setText( getTimeout() )
class javadocInfo_02(java.lang.Runnable):
#---------------------------------------------------------------------------
# Name: run()
# Role: Instantiate the user class
# Note: Invoked by the Swing Event Dispatch Thread
#---------------------------------------------------------------------------
def run(self):
frame = JFrame('javadocInfo_02',
locationRelativeTo=None,
size=(350, 225),
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
model = DefaultListModel()
model.addElement('One moment please...')
self.List = JList(model,
valueChanged=self.pick,
selectionMode=ListSelectionModel.SINGLE_SELECTION)
frame.add(JScrollPane(self.List), BorderLayout.CENTER)
self.msg = JTextField()
frame.add(self.msg, BorderLayout.SOUTH)
self.Links = {}
soupTask(
self.List, # The visible JList instance
self.msg, # The message area (JTextField)
JAVADOC_URL, # Remote web page URL to be processed
self.Links # Dictionary of links found
).execute()
frame.setVisible(1)
#---------------------------------------------------------------------------
# Name: pick()
# Role: ListSelectionListener event handler
#---------------------------------------------------------------------------
def pick(self, e):
#-----------------------------------------------------------------------
# Note: Ignore valueIsAdjusting events
#-----------------------------------------------------------------------
if not e.getValueIsAdjusting():
List = self.List
model = List.getModel()
#-------------------------------------------------------------------
# Ignore events for initial "One moment please..." list
#-------------------------------------------------------------------
if model.getSize() > 1:
#---------------------------------------------------------------
# Is an item selected, or not?
#---------------------------------------------------------------
index = List.getSelectedIndex()
if index > -1:
choice = model.elementAt(index)
self.msg.setText(self.Links[choice])
else:
self.msg.setText('Make a selection')
class PrefsPanel(JPanel):
"""JPanle with gui for tool preferences
"""
def __init__(self, app):
strings = app.strings
self.setLayout(GridLayout(3, 2, 5, 5))
userLbl = JLabel(strings.getString("osmose_pref_username"))
self.userTextField = JTextField(20)
self.userTextField.setToolTipText(strings.getString("osmose_pref_username_tooltip"))
levelLbl = JLabel(strings.getString("osmose_pref_level"))
self.levels = ["1", "1,2", "1,2,3", "2", "3"]
self.levelsCombo = JComboBox(self.levels)
self.levelsCombo.setToolTipText(strings.getString("osmose_pref_level_tooltip"))
limitLbl = JLabel(strings.getString("osmose_pref_limit"))
self.limitTextField = JTextField(20)
self.limitTextField.setToolTipText(strings.getString("osmose_pref_limit_tooltip"))
self.add(userLbl)
self.add(self.userTextField)
self.add(levelLbl)
self.add(self.levelsCombo)
self.add(limitLbl)
self.add(self.limitTextField)
def update_gui(self, preferences):
"""Update preferences gui
"""
self.userTextField.setText(preferences["username"])
self.levelsCombo.setSelectedIndex(self.levels.index(preferences["level"]))
self.limitTextField.setText(str(preferences["limit"]))
def read_gui(self):
"""Read preferences from gui
"""
username = self.userTextField.getText()
level = self.levelsCombo.getSelectedItem()
limit = self.limitTextField.getText()
try:
limit = Integer.parseInt(limit)
if limit > 500:
limit = 500
limit = str(limit)
except NumberFormatException:
limit = ""
preferences = {"username": username.strip(),
"level": level,
"limit": limit}
return preferences
def output(self, value):
#url = "https://dict.leo.org/englisch-deutsch/dog"
#import urllib.request
#with urllib.request.urlopen(url) as response:
#html = response.read()
#with open("leoausgabe.txt","w") as f:
#f.write(str(html))
t = ''
frame = JFrame(
'Lektion erstellen',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
size=(500, 500),
)
def change_text(event):
text = feld.getText()
name = feld2.getText() + ".csv"
with open(name, "w") as f:
f.write(text)
#print(name + " gespeichert")
#print(text)
t = text
self.send(t)
#return(t)
button = JButton('Lektion speichern!',
actionPerformed=change_text,
size=(10, 20))
button.setBounds(20, 40, 20, 40)
pnl = JPanel()
pnl.setLayout(BoxLayout(pnl, BoxLayout.Y_AXIS))
feld = JTextArea()
feld.editable = True
feld.setText("Deutsch,Englisch\n")
feld2 = JTextField()
feld2.setText("Ersetzen durch Namen der Lektion")
pnl.add(feld2)
pnl.add(feld)
pnl.add(button)
frame.add(pnl)
frame.setVisible(True)
#change_text(value)
print(t)
print "Lektion erstellt"
def gui(self):
# Hilfsfunktion für event
# erstellt ein Rezeptobjekt anhand einer URL
# schließt die GUI
def create(event):
url = field.getText()
self.recipe = Recipe(url)
frame.dispose()
print("created recipe for " + self.recipe.get_title())
# der Dialog wartet, bis "continue" gesendet wird
self.send("continue")
# Frame erstellen
frame = JFrame(
'URL eingeben',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
size=(480, 200),
)
frame.setLayout(None)
# Text im Frame
fieldlabel = JLabel()
fieldlabel.setText(
"<html><font size=+1>Geben Sie die Internetadresse des Rezepts ein</font></html>"
)
fieldlabel.setBounds(20, 20, 500, 40)
frame.add(fieldlabel)
# Textfeld im Frame
field = JTextField()
field.setText("https://www.chefkoch.de/rezepte/...")
field.setBounds(20, 60, 411, 40)
frame.add(field)
# Button im Frame
# ruft Hilfsfunktion create auf
button = JButton("Los!", actionPerformed=create)
button.setBounds(155, 100, 150, 30)
frame.add(button)
#Frame anzeigen
frame.setVisible(True)
def getGUI(sym_dict):
global frame, outCheckbox, fillCheckbox, slider, colorTF, widthTF
frame = JFrame("Border Symbology", defaultCloseOperation=JFrame.DISPOSE_ON_CLOSE,
bounds=(100, 100, 450, 200), layout=FlowLayout(), resizable=0)
colorL = JLabel('Color: ')
colorTF = JTextField(20)
color = sym_dict["color"]
color = Color(color.getRed(), color.getGreen(), color.getBlue(), sym_dict["alpha"])
colorTF.setBackground(color)
colorTF.setText(color.toString())
colorB = JButton('...', actionPerformed=colorChooser)
frame.add(colorL)
frame.add(colorTF)
frame.add(colorB)
widthL = JLabel('Width: ')
widthTF = JTextField(3)
widthTF.setText(str(sym_dict["width"]))
frame.add(widthL)
frame.add(widthTF)
alphaL = JLabel('Transparency: ')
frame.add(alphaL)
# Create a horizontal slider with min=0, max=100, value=50
slider = JSlider()
slider.setPreferredSize(Dimension(200, 50))
slider.setValue(sym_dict["alpha"]*100/255)
slider.setMajorTickSpacing(25)
slider.setMinorTickSpacing(5)
slider.setPaintTicks(1)
slider.setPaintLabels(1)
applyButton = JButton("Apply", actionPerformed=action)
acceptButton = JButton("Accept", actionPerformed=accept)
frame.add(slider)
frame.add(applyButton)
frame.add(acceptButton)
frame.show()
def inputBox(message, defaultText=None):
"""Opens up a popup input dialog box.
This dialog box will show a prompt message, and allow the user to
type in a string. When the user is done, they can press "OK" or
"Cancel". If OK is pressed, this function will return with the value
that they typed in. If Cancel is pressed, this function will return
the value None.
Args:
message (str): The message to display for the input box. Will
accept html formatting.
defaultText (str): The default text to initialize the input box
with. Optional.
Returns:
str: The string value that was entered in the input box.
"""
options = ["OK", "Cancel"]
panel = JPanel()
label = JLabel("{}: ".format(message))
panel.add(label)
text_field = JTextField(25)
text_field.setText(defaultText)
panel.add(text_field)
choice = JOptionPane.showOptionDialog(
None,
panel,
"Input",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE,
None,
options,
options[0],
)
return text_field.getText() if choice == JOptionPane.OK_OPTION else None
class EditSettingsView(JDialog):
def __init__(self, controller, working_dir, servers, console_style,
edit_area_style, keystrokes, languages, projects):
self.logger = logging.getLogger("NammuController")
self.setAlwaysOnTop(True)
self.controller = controller
self.working_dir = working_dir
self.servers = servers
self.keystrokes = keystrokes
self.languages = languages
self.projects = projects
self.console_fontsize = console_style['fontsize']['user']
self.console_font_color = console_style['font_color']['user']
self.console_bg_color = console_style['background_color']['user']
self.edit_area_fontsize = edit_area_style['fontsize']['user']
self.pane = self.getContentPane()
# Grab the console color options from the console view
self.consoleView = self.controller.controller.consoleController.view
self.color_options = self.consoleView.colors.keys()
def build(self):
'''
Create all tab panels and put together to form the settings window.
'''
self.setLayout(BorderLayout())
self.add(self.build_tabbed_panel(), BorderLayout.CENTER)
self.add(self.build_buttons_panel(), BorderLayout.SOUTH)
def build_tabbed_panel(self):
'''
Build panel with tabs for each of the settings editable sections.
'''
tabbed_pane = JTabbedPane()
tab_titles = [
"General", "Appearance", "Keystrokes", "Languages", "Projects"
]
for title in tab_titles:
panel = self.build_settings_panel(title.lower())
tabbed_pane.addTab(title, panel)
return tabbed_pane
def build_settings_panel(self, text):
'''
Call correspondent method to create panel for given tab text.
'''
panel = getattr(self, "build_{}_panel".format(text))()
return panel
def build_general_panel(self):
'''
Create the panel that'll go in the General tab. This should contain
options for choosing which server to use for validation as well as
default working dir.
'''
panel = JPanel(GridBagLayout())
constraints = self.add_constraints(GridBagConstraints(),
insets=Insets(10, 10, 10, 10))
self.build_working_dir_panel(constraints, panel)
self.build_servers_panel(constraints, panel)
return panel
def add_constraints(self,
constraints,
weightx=None,
gridx=None,
gridy=None,
fill=None,
insets=None,
gridwidth=None,
anchor=None):
'''
Wrapper around the various constraints we need to set.
'''
# Cant use pythonic truth value test as we need 0 to evaluate as true
if weightx is not None:
constraints.weightx = weightx
if gridx is not None:
constraints.gridx = gridx
if gridy is not None:
constraints.gridy = gridy
if fill is not None:
constraints.fill = fill
if insets is not None:
constraints.insets = insets
if gridwidth is not None:
constraints.gridwidth = gridwidth
if anchor is not None:
constraints.anchor = anchor
return constraints
def build_working_dir_panel(self, constraints, panel):
'''
Working directory row: label + field + button
This is for users to browse for their preferred default directory
when opening/creating a new file.
'''
working_dir_label = JLabel("Working directory:")
constraints = self.add_constraints(constraints,
weightx=0.30,
gridx=0,
gridy=0,
anchor=GridBagConstraints.EAST)
panel.add(working_dir_label, constraints)
self.wd_field = JTextField()
self.wd_field.setEditable(False)
# Can't find an elegant way to default to something that would be
# crossplatform, and I can't leave the default field empty.
if self.working_dir['default'] != "None":
self.wd_field.setText(self.working_dir['default'])
else:
self.wd_field.setText(os.getcwd())
constraints = self.add_constraints(constraints,
weightx=0.60,
gridx=1,
gridy=0,
fill=GridBagConstraints.HORIZONTAL,
insets=Insets(10, 10, 10, 5))
panel.add(self.wd_field, constraints)
constraints.fill = 0
button = JButton("Browse", actionPerformed=self.browse)
constraints = self.add_constraints(constraints,
weightx=0.10,
gridx=2,
gridy=0,
insets=Insets(10, 0, 10, 10))
panel.add(button, constraints)
def build_console_background_color_panel(self, constraints, panel):
'''
Server location row: label + dropdown
Contains a drop down with the servers to choose from.
'''
console_bg_label = JLabel("Console background color:")
constraints = self.add_constraints(constraints,
weightx=0.30,
gridx=0,
gridy=2)
panel.add(console_bg_label, constraints)
self.bg_color_combo = self.build_combobox(self.color_options,
self.console_bg_color)
constraints = self.add_constraints(constraints,
weightx=0.70,
gridx=1,
gridy=2,
gridwidth=2,
fill=GridBagConstraints.HORIZONTAL)
panel.add(self.bg_color_combo, constraints)
def build_console_font_color_panel(self, constraints, panel):
'''
Server location row: label + dropdown
Contains a drop down with the servers to choose from.
'''
console_font_label = JLabel("Console font color:")
constraints = self.add_constraints(constraints,
weightx=0.30,
gridx=0,
gridy=3)
panel.add(console_font_label, constraints)
self.font_color_combo = self.build_combobox(self.color_options,
self.console_font_color)
constraints = self.add_constraints(constraints,
weightx=0.70,
gridx=1,
gridy=3,
gridwidth=2,
fill=GridBagConstraints.HORIZONTAL)
panel.add(self.font_color_combo, constraints)
def build_servers_panel(self, constraints, panel):
'''
Server location row: label + dropdown
Contains a drop down with the servers to choose from.
'''
server_label = JLabel("ORACC server location:")
constraints = self.add_constraints(constraints,
weightx=0.30,
gridx=0,
gridy=1,
insets=Insets(10, 10, 80, 10))
panel.add(server_label, constraints)
self.combo = self.build_servers_combobox()
constraints = self.add_constraints(constraints,
weightx=0.70,
gridx=1,
gridy=1,
gridwidth=2,
fill=GridBagConstraints.HORIZONTAL)
panel.add(self.combo, constraints)
def build_console_font_panel(self, constraints, panel):
'''
Font size on a textfield.
'''
fontzise_label = JLabel("Console font size:")
constraints = self.add_constraints(constraints,
weightx=0.20,
gridx=0,
gridy=0,
fill=GridBagConstraints.HORIZONTAL)
panel.add(fontzise_label, constraints)
self.fs_field = JTextField()
self.fs_field.setEditable(True)
if self.console_fontsize:
self.fs_field.setText("{}".format(self.console_fontsize))
else:
self.fs_field.setText(
self.controller.config['console_style']['fontsize']['default'])
constraints = self.add_constraints(constraints,
weightx=0.80,
gridx=1,
gridy=0,
fill=GridBagConstraints.HORIZONTAL)
panel.add(self.fs_field, constraints)
def build_edit_area_font_panel(self, constraints, panel):
'''
Font size on a textfield.
'''
fontzise_label = JLabel("Edit area font size:")
constraints = self.add_constraints(constraints,
weightx=0.20,
gridx=0,
gridy=4)
panel.add(fontzise_label, constraints)
self.edit_area_fs_field = JTextField()
self.edit_area_fs_field.setEditable(True)
if self.edit_area_fontsize:
self.edit_area_fs_field.setText("{}".format(
self.edit_area_fontsize))
else:
self.edit_area_fs_field.setText(
self.controller.config['edit_area_style']['fontsize']
['default'])
constraints = self.add_constraints(constraints,
weightx=0.80,
gridx=1,
gridy=4,
fill=GridBagConstraints.HORIZONTAL)
panel.add(self.edit_area_fs_field, constraints)
def build_combobox(self, choices, default):
'''
Generic method to construct a combobox. choices should be an iterable
of strings of the choices to be made and default should be a string
which is equal to one of the values within the iterable.
'''
combo = JComboBox()
for choice in choices:
combo.addItem(choice)
combo.setSelectedItem(default)
return combo
def build_servers_combobox(self):
combo = JComboBox()
# Go through list of servers and add to combo box.
for server in self.servers.keys():
if server != "default":
combo_item = "{}: {}:{}".format(server,
self.servers[server]['url'],
self.servers[server]['port'])
combo.addItem(combo_item)
# If this item is the default one, set it as selected
if server == self.servers['default']:
combo.setSelectedItem(combo_item)
return combo
def build_buttons_panel(self):
'''
Builds the buttons panel to save or cancel changes.
TODO: Reset button to reset to defaults?
'''
panel = JPanel(FlowLayout())
panel.add(JButton('Cancel', actionPerformed=self.cancel))
panel.add(JButton('Save', actionPerformed=self.save))
return panel
def build_keystrokes_panel(self):
'''
Create the panel that'll go in the Keystrokes tab. This should contain
options for choosing which keystrokes are to be assigned to which
actions.
'''
panel = JPanel()
label = JLabel("Coming soon...")
panel.add(label, BorderLayout.CENTER)
return panel
def build_languages_panel(self):
'''
Create the panel that'll go in the Languages tab. This should contain
options for choosing which is the list of languages that can be
included from the new ATF window and their abbrv.
'''
panel = JPanel()
label = JLabel("Coming soon...")
panel.add(label, BorderLayout.CENTER)
return panel
def build_projects_panel(self):
'''
Create the panel that'll go in the Projects tab. This should contain
the list of preferred projects and a means to select which is the
preferred default.
'''
panel = JPanel()
label = JLabel("Coming soon...")
panel.add(label, BorderLayout.CENTER)
return panel
def build_appearance_panel(self):
'''
Create the panel that'll go in the General tab. This should contain
options for choosing which server to use for validation as well as
default working dir.
'''
panel = JPanel(GridBagLayout())
constraints = self.add_constraints(GridBagConstraints(),
insets=Insets(10, 10, 10, 10))
self.build_console_font_panel(constraints, panel)
self.build_console_font_color_panel(constraints, panel)
self.build_console_background_color_panel(constraints, panel)
self.build_edit_area_font_panel(constraints, panel)
return panel
def display(self):
'''
Displays window.
'''
self.build()
self.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
self.setResizable(False)
self.setTitle("Edit settings")
self.pack()
self.setLocationRelativeTo(None)
self.visible = 1
def display_error(self, keyword):
'''
Display error message when keyword is not in settings file.
'''
pass
def cancel(self, event=None):
'''
Close window and don't save changes.
'''
self.dispose()
def validate_fontsize(self, input_size, target_key):
'''
Method to validate an input fontsize. The target key points to either
the console font sizes 'console_style' or the edit area font sizes
'edit_area_style'. If the value is invalid, return the previous user
fontsize that was stored.
The second return value is a bool indicating if the value has changed.
'''
# Extract plain english from key name for use in error message
target = target_key[:-6].replace('_', ' ')
# Use isnumeric() to test if a unicode string only has digits
if (input_size.isnumeric() and (8 <= int(input_size) <= 30)):
return input_size, True
else:
input_size = self.controller.config[target_key]['fontsize']['user']
self.logger.error("Invalid {} font size. Please enter a "
"number between 8 and 36.\n\n"
"Font size left at "
"previous value: {}".format(target, input_size))
return input_size, False
def validate_colors(self, bg_color, font_color):
'''
Validate console colors to ensure they do not match.
The second return value is a bool indicating if the value has changed.
'''
valid = True
if bg_color == font_color:
config = self.controller.config
self.logger.error("Console font colour cannot match background"
" colour. Resetting to default values.")
bg_color = config['console_style']['background_color']['default']
font_color = config['console_style']['font_color']['default']
valid = False
return bg_color, font_color, valid
def validate_working_dir(self, working_dir):
'''
Method to validate input working directories. If directory does not
exist or if a path to a file is provided instead of a path to a
directory the method returns None.
The second return value is a bool indicating if the value has changed.
'''
if os.path.isdir(working_dir):
return working_dir, True
else:
self.logger.error("{} is not a valid working directory."
" No working directory has been "
"saved".format(working_dir))
return None, False
def validate_all_inputs(self, working_dir, console_fontsize,
edit_area_fontsize, bg_color, font_color):
'''
Wrapper around the input validation methods. Returns a tuple containing
the validated inputs with the last value in the tuple a boolean set to
False if any of the values have been altered during the validation
and True if there have been no changes.
'''
# Collect the results of each validation. In future we might use this
# to provide more detailed error logging on bad user input
validation_results = []
# Validate the working directory input string
working_dir, v = self.validate_working_dir(working_dir)
validation_results.append(v)
# Validate the input fontsizes
con_size, v = self.validate_fontsize(console_fontsize, 'console_style')
validation_results.append(v)
edit_size, v = self.validate_fontsize(edit_area_fontsize,
'edit_area_style')
validation_results.append(v)
# Validate input console colors
bg_color, font_color, v = self.validate_colors(bg_color, font_color)
validation_results.append(v)
return (working_dir, int(con_size), font_color, bg_color,
int(edit_size), all(validation_results))
def save(self, event=None):
'''
Save changes made by user on local settings file.
'''
# Update only the working_dir and the server for now
# TODO: update keystrokes, projects list, etc.
working_dir = self.wd_field.getText()
# Read the fontsize from the textfield
console_fontsize = self.fs_field.getText()
edit_area_fontsize = self.edit_area_fs_field.getText()
# Get the user selected font and background colours
bg_color = self.bg_color_combo.getSelectedItem()
font_color = self.font_color_combo.getSelectedItem()
validated = self.validate_all_inputs(working_dir, console_fontsize,
edit_area_fontsize, bg_color,
font_color)
# The server format is "name: url:port". We only need "name"
server = self.combo.getSelectedItem().split(':')[0]
self.controller.update_config(validated[0], server, validated[1],
validated[2], validated[3],
int(validated[4]))
# If no values have been changed, print that settings have been
# updated without errors
if validated[5]:
self.logger.info("Settings have been successfully updated.")
# On saving settings, update the console and edit area properties
self.controller.refreshConsole()
self.controller.refreshEditArea()
# Close window
self.dispose()
# Refresh the syntax highlighting in a separate thread so it updates
# after everything else has been done.
runSwingLater(self.controller.controller.initHighlighting)
def browse(self, event=None):
'''
Open new dialog for the user to select a path as default working dir.
'''
default_path = self.wd_field.getText()
if not os.path.isdir(default_path):
default_path = os.getcwd()
fileChooser = JFileChooser(default_path)
fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
# Fixed showDialog bug using showOpenDialog instead. The former was
# duplicating the last folder name in the path due to a Java bug in
# OSX in the implementation of JFileChooser!
status = fileChooser.showOpenDialog(self)
if status == JFileChooser.APPROVE_OPTION:
self.wd_field.setText(fileChooser.getSelectedFile().toString())
class BurpExtender(IBurpExtender, ITab, IMessageEditorController, AbstractTableModel, IContextMenuFactory):
def registerExtenderCallbacks(self, callbacks):
# keep a reference to our callbacks object
self._callbacks = callbacks
# obtain an extension helpers object
self._helpers = callbacks.getHelpers()
# set our extension name
callbacks.setExtensionName("PT Vulnerabilities Manager")
self.config = SafeConfigParser()
self.createSection('projects')
self.createSection('general')
self.config.read('config.ini')
self.chooser = JFileChooser()
# create the log and a lock on which to synchronize when adding log entries
self._log = ArrayList()
self._lock = Lock()
self.logTable = Table(self)
self.logTable.getColumnModel().getColumn(0).setMaxWidth(35)
self.logTable.getColumnModel().getColumn(1).setMinWidth(100)
self._requestViewer = self._callbacks.createMessageEditor(self, False)
self._responseViewer = self._callbacks.createMessageEditor(self, False)
self.initVulnerabilityTab()
self.initProjSettingsTab()
self.initTabs()
self.initCallbacks()
if self.projPath.getText() != None:
self.loadVulnerabilities(self.projPath.getText())
print "Thank you for installing PT Vulnerabilities Manager v1.0 extension"
print "by Barak Tawily\n\n\n"
print "Disclaimer:\nThis extension might create folders and files in your hardisk which might be declared as sensitive information, make sure you are creating projects under encrypted partition"
return
def initVulnerabilityTab(self):
#
## init vulnerability tab
#
nameLabel = JLabel("Vulnerability Name:")
nameLabel.setBounds(10, 10, 140, 30)
self.addButton = JButton("Add",actionPerformed=self.addVuln)
self.addButton.setBounds(10, 500, 100, 30)
rmVulnButton = JButton("Remove",actionPerformed=self.rmVuln)
rmVulnButton.setBounds(465, 500, 100, 30)
mitigationLabel = JLabel("Mitigation:")
mitigationLabel.setBounds(10, 290, 150, 30)
addSSBtn = JButton("Add SS",actionPerformed=self.addSS)
addSSBtn.setBounds(750, 40, 110, 30)
deleteSSBtn = JButton("Remove SS",actionPerformed=self.removeSS)
deleteSSBtn.setBounds(750, 75, 110, 30)
piclistLabel = JLabel("Images list:")
piclistLabel.setBounds(580, 10, 140, 30)
self.screenshotsList = DefaultListModel()
self.ssList = JList(self.screenshotsList)
self.ssList.setBounds(580, 40, 150, 250)
self.ssList.addListSelectionListener(ssChangedHandler(self))
self.ssList.setBorder(BorderFactory.createLineBorder(Color.GRAY))
previewPicLabel = JLabel("Selected image preview: (click to open in image viewer)")
previewPicLabel.setBounds(580, 290, 500, 30)
copyImgMenu = JMenuItem("Copy")
copyImgMenu.addActionListener(copyImg(self))
self.imgMenu = JPopupMenu("Popup")
self.imgMenu.add(copyImgMenu)
self.firstPic = JLabel()
self.firstPic.setBorder(BorderFactory.createLineBorder(Color.GRAY))
self.firstPic.setBounds(580, 320, 550, 400)
self.firstPic.addMouseListener(imageClicked(self))
self.vulnName = JTextField("")
self.vulnName.getDocument().addDocumentListener(vulnTextChanged(self))
self.vulnName.setBounds(140, 10, 422, 30)
sevirities = ["Unclassified", "Critical","High","Medium","Low"]
self.threatLevel = JComboBox(sevirities);
self.threatLevel.setBounds(140, 45, 140, 30)
colors = ["Color:", "Green", "Red"]
self.colorCombo = JComboBox(colors);
self.colorCombo.setBounds(465, 45, 100, 30)
self.colorCombo
severityLabel = JLabel("Threat Level:")
severityLabel.setBounds(10, 45, 100, 30)
descriptionLabel = JLabel("Description:")
descriptionLabel.setBounds(10, 80, 100, 30)
self.descriptionString = JTextArea("", 5, 30)
self.descriptionString.setWrapStyleWord(True);
self.descriptionString.setLineWrap(True)
self.descriptionString.setBounds(10, 110, 555, 175)
descriptionStringScroll = JScrollPane(self.descriptionString)
descriptionStringScroll.setBounds(10, 110, 555, 175)
descriptionStringScroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED)
self.mitigationStr = JTextArea("", 5, 30)
self.mitigationStr.setWrapStyleWord(True);
self.mitigationStr.setLineWrap(True)
self.mitigationStr.setBounds(10, 320, 555, 175)
mitigationStrScroll = JScrollPane(self.mitigationStr)
mitigationStrScroll.setBounds(10, 320, 555, 175)
mitigationStrScroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED)
self.pnl = JPanel()
self.pnl.setBounds(0, 0, 1000, 1000);
self.pnl.setLayout(None);
self.pnl.add(addSSBtn)
self.pnl.add(piclistLabel)
self.pnl.add(nameLabel)
self.pnl.add(deleteSSBtn)
self.pnl.add(rmVulnButton)
self.pnl.add(severityLabel)
self.pnl.add(mitigationLabel)
self.pnl.add(descriptionLabel)
self.pnl.add(previewPicLabel)
self.pnl.add(mitigationStrScroll)
self.pnl.add(descriptionStringScroll)
self.pnl.add(self.ssList)
self.pnl.add(self.firstPic)
self.pnl.add(self.addButton)
self.pnl.add(self.vulnName)
self.pnl.add(self.threatLevel)
self.pnl.add(self.colorCombo)
def initProjSettingsTab(self):
# init project settings
projNameLabel = JLabel("Name:")
projNameLabel.setBounds(10, 50, 140, 30)
self.projName = JTextField("")
self.projName.setBounds(140, 50, 320, 30)
self.projName.getDocument().addDocumentListener(projTextChanged(self))
detailsLabel = JLabel("Details:")
detailsLabel.setBounds(10, 120, 140, 30)
reportLabel = JLabel("Generate Report:")
reportLabel.setBounds(10, 375, 140, 30)
types = ["DOCX","HTML","XLSX"]
self.reportType = JComboBox(types)
self.reportType.setBounds(10, 400, 140, 30)
generateReportButton = JButton("Generate", actionPerformed=self.generateReport)
generateReportButton.setBounds(160, 400, 90, 30)
self.projDetails = JTextArea("", 5, 30)
self.projDetails.setWrapStyleWord(True);
self.projDetails.setLineWrap(True)
projDetailsScroll = JScrollPane(self.projDetails)
projDetailsScroll.setBounds(10, 150, 450, 175)
projDetailsScroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED)
projPathLabel = JLabel("Path:")
projPathLabel.setBounds(10, 90, 140, 30)
self.projPath = JTextField("")
self.projPath.setBounds(140, 90, 320, 30)
chooseProjPathButton = JButton("Browse...",actionPerformed=self.chooseProjPath)
chooseProjPathButton.setBounds(470, 90, 100, 30)
importProjButton = JButton("Import",actionPerformed=self.importProj)
importProjButton.setBounds(470, 10, 100, 30)
exportProjButton = JButton("Export",actionPerformed=self.exportProj)
exportProjButton.setBounds(575, 10, 100, 30)
openProjButton = JButton("Open Directory",actionPerformed=self.openProj)
openProjButton.setBounds(680, 10, 130, 30)
currentProjectLabel = JLabel("Current:")
currentProjectLabel.setBounds(10, 10, 140, 30)
projects = self.config.options('projects')
self.currentProject = JComboBox(projects)
self.currentProject.addActionListener(projectChangeHandler(self))
self.currentProject.setBounds(140, 10, 140, 30)
self.autoSave = JCheckBox("Auto Save Mode")
self.autoSave.setEnabled(False) # implement this feature
self.autoSave.setBounds(300, 10, 140, 30)
self.autoSave.setToolTipText("Will save any changed value while focus is out")
addProjButton = JButton("Add / Update",actionPerformed=self.addProj)
addProjButton.setBounds(10, 330, 150, 30)
removeProjButton = JButton("Remove Current",actionPerformed=self.rmProj)
removeProjButton.setBounds(315, 330, 146, 30)
generalOptions = self.config.options('general')
if 'default project' in generalOptions:
defaultProj = self.config.get('general','default project')
self.currentProject.getModel().setSelectedItem(defaultProj)
self.projPath.setText(self.config.get('projects',self.currentProject.getSelectedItem()))
self.clearProjTab = True
self.projectSettings = JPanel()
self.projectSettings.setBounds(0, 0, 1000, 1000)
self.projectSettings.setLayout(None)
self.projectSettings.add(reportLabel)
self.projectSettings.add(detailsLabel)
self.projectSettings.add(projPathLabel)
self.projectSettings.add(addProjButton)
self.projectSettings.add(openProjButton)
self.projectSettings.add(projNameLabel)
self.projectSettings.add(projDetailsScroll)
self.projectSettings.add(importProjButton)
self.projectSettings.add(exportProjButton)
self.projectSettings.add(removeProjButton)
self.projectSettings.add(generateReportButton)
self.projectSettings.add(chooseProjPathButton)
self.projectSettings.add(currentProjectLabel)
self.projectSettings.add(self.projPath)
self.projectSettings.add(self.autoSave)
self.projectSettings.add(self.projName)
self.projectSettings.add(self.reportType)
self.projectSettings.add(self.currentProject)
def initTabs(self):
#
## init autorize tabs
#
self._splitpane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT)
self.scrollPane = JScrollPane(self.logTable)
self._splitpane.setLeftComponent(self.scrollPane)
colorsMenu = JMenu("Paint")
redMenu = JMenuItem("Red")
noneMenu = JMenuItem("None")
greenMenu = JMenuItem("Green")
redMenu.addActionListener(paintChange(self, "Red"))
noneMenu.addActionListener(paintChange(self, None))
greenMenu.addActionListener(paintChange(self, "Green"))
colorsMenu.add(redMenu)
colorsMenu.add(noneMenu)
colorsMenu.add(greenMenu)
self.menu = JPopupMenu("Popup")
self.menu.add(colorsMenu)
self.tabs = JTabbedPane()
self.tabs.addTab("Request", self._requestViewer.getComponent())
self.tabs.addTab("Response", self._responseViewer.getComponent())
self.tabs.addTab("Vulnerability", self.pnl)
self.tabs.addTab("Project Settings", self.projectSettings)
self.tabs.setSelectedIndex(2)
self._splitpane.setRightComponent(self.tabs)
def initCallbacks(self):
#
## init callbacks
#
# customize our UI components
self._callbacks.customizeUiComponent(self._splitpane)
self._callbacks.customizeUiComponent(self.logTable)
self._callbacks.customizeUiComponent(self.scrollPane)
self._callbacks.customizeUiComponent(self.tabs)
self._callbacks.registerContextMenuFactory(self)
# add the custom tab to Burp's UI
self._callbacks.addSuiteTab(self)
def loadVulnerabilities(self, projPath):
self.clearList(None)
selected = False
for root, dirs, files in os.walk(projPath): # make it go only for dirs
for dirName in dirs:
xmlPath = projPath+"/"+dirName+"/vulnerability.xml"
# xmlPath = xmlPath.replace("/","//")
document = self.getXMLDoc(xmlPath)
nodeList = document.getDocumentElement().getChildNodes()
vulnName = nodeList.item(0).getTextContent()
severity = nodeList.item(1).getTextContent()
description = nodeList.item(2).getTextContent()
mitigation = nodeList.item(3).getTextContent()
color = nodeList.item(4).getTextContent()
test = vulnerability(vulnName,severity,description,mitigation,color)
self._lock.acquire()
row = self._log.size()
self._log.add(test)
self.fireTableRowsInserted(row, row)
self._lock.release()
if vulnName == self.vulnName.getText():
self.logTable.setRowSelectionInterval(row,row)
selected = True
if selected == False and self._log.size() > 0:
self.logTable.setRowSelectionInterval(0, 0)
self.loadVulnerability(self._log.get(0))
def createSection(self, sectioName):
self.config.read('config.ini')
if not (sectioName in self.config.sections()):
self.config.add_section(sectioName)
cfgfile = open("config.ini",'w')
self.config.write(cfgfile)
cfgfile.close()
def saveCfg(self):
f = open('config.ini', 'w')
self.config.write(f)
f.close()
def getXMLDoc(self, xmlPath):
try:
document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(xmlPath)
return document
except:
self._extender.popup("XML file not found")
return
def saveXMLDoc(self, doc, xmlPath):
transformerFactory = TransformerFactory.newInstance()
transformer = transformerFactory.newTransformer()
source = DOMSource(doc)
result = StreamResult(File(xmlPath))
transformer.transform(source, result)
def generateReport(self,event):
if self.reportType.getSelectedItem() == "HTML":
path = self.reportToHTML()
if self.reportType.getSelectedItem() == "XLSX":
path = self.reportToXLS()
if self.reportType.getSelectedItem() == "DOCX":
path = self.generateReportFromDocxTemplate('template.docx',"newfile.docx", 'word/document.xml')
n = JOptionPane.showConfirmDialog(None, "Report generated successfuly:\n%s\nWould you like to open it?" % (path), "PT Manager", JOptionPane.YES_NO_OPTION)
if n == JOptionPane.YES_OPTION:
os.system('"' + path + '"') # Bug! stucking burp until the file get closed
def exportProj(self,event):
self.chooser.setDialogTitle("Save project")
Ffilter = FileNameExtensionFilter("Zip files", ["zip"])
self.chooser.setFileFilter(Ffilter)
returnVal = self.chooser.showSaveDialog(None)
if returnVal == JFileChooser.APPROVE_OPTION:
dst = str(self.chooser.getSelectedFile())
shutil.make_archive(dst,"zip",self.getCurrentProjPath())
self.popup("Project export successfuly")
def importProj(self,event):
self.chooser.setDialogTitle("Select project zip to directory")
Ffilter = FileNameExtensionFilter("Zip files", ["zip"])
self.chooser.setFileFilter(Ffilter)
returnVal = self.chooser.showOpenDialog(None)
if returnVal == JFileChooser.APPROVE_OPTION:
zipPath = str(self.chooser.getSelectedFile())
self.chooser.setDialogTitle("Select project directory")
self.chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
returnVal = self.chooser.showOpenDialog(None)
if returnVal == JFileChooser.APPROVE_OPTION:
projPath = str(self.chooser.getSelectedFile()) + "/PTManager"
with zipfile.ZipFile(zipPath, "r") as z:
z.extractall(projPath)
xmlPath = projPath + "/project.xml"
document = self.getXMLDoc(xmlPath)
nodeList = document.getDocumentElement().getChildNodes()
projName = nodeList.item(0).getTextContent()
nodeList.item(1).setTextContent(projPath)
self.saveXMLDoc(document, xmlPath)
self.config.set('projects', projName, projPath)
self.saveCfg()
self.reloadProjects()
self.currentProject.getModel().setSelectedItem(projName)
self.clearVulnerabilityTab()
def reportToXLS(self):
if not xlsxwriterImported:
self.popup("xlsxwriter library is not imported")
return
workbook = xlsxwriter.Workbook(self.getCurrentProjPath() + '/PT Manager Report.xlsx')
worksheet = workbook.add_worksheet()
bold = workbook.add_format({'bold': True})
worksheet.write(0, 0, "Vulnerability Name", bold)
worksheet.write(0, 1, "Threat Level", bold)
worksheet.write(0, 2, "Description", bold)
worksheet.write(0, 3, "Mitigation", bold)
row = 1
for i in range(0,self._log.size()):
worksheet.write(row, 0, self._log.get(i).getName())
worksheet.write(row, 1, self._log.get(i).getSeverity())
worksheet.write(row, 2, self._log.get(i).getDescription())
worksheet.write(row, 3, self._log.get(i).getMitigation())
row = row + 1
# add requests and images as well
workbook.close()
return self.getCurrentProjPath() + '/PT Manager Report.xlsx'
def reportToHTML(self):
htmlContent = """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="he" dir="ltr">
<head>
<title>PT Manager Report</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<style>
body {
background-repeat: no-repeat;
background-attachment: fixed;
font-family: Arial,Tahoma,sens-serif;
font-size: 13px;
margin: auto;
}
#warpcenter {
width: 900px;
margin: 0px auto;
}
table {
border: 2px dashed #000000;
}
td {
border-top: 2px dashed #000000;
padding: 10px;
}
img {
border: 0px;
}
</style>
<script language="javascript">
function divHideShow(divToHideOrShow)
{
var div = document.getElementById(divToHideOrShow);
if (div.style.display == "block")
{
div.style.display = "none";
}
else
{
div.style.display = "block";
}
}
</script>
</head>
<body>
<div id="warpcenter">
<h1> PT Manager Report </h1>
<h2> Project: %s</h1>
""" % (self.projName.getText())
for i in range(0,self._log.size()):
name = self._log.get(i).getName()
request = "None"
response = "None"
path = self.getVulnReqResPath("request",name)
if os.path.exists(path):
request = self.newlineToBR(self.getFileContent(path))
path = self.getVulnReqResPath("response",name)
if os.path.exists(path):
response = self.newlineToBR(self.getFileContent(path))
images = ""
for fileName in os.listdir(self.projPath.getText()+"/"+self.clearStr(name)):
if fileName.endswith(".jpg"):
images += "%s<br><img src=\"%s\"><br><br>" % (fileName, self.projPath.getText()+"/"+self.clearStr(name) + "/" + fileName)
description = self.newlineToBR(self._log.get(i).getDescription())
mitigation = self.newlineToBR(self._log.get(i).getMitigation())
htmlContent += self.convertVulntoTable(i,name,self._log.get(i).getSeverity(), description,mitigation, request, response, images)
htmlContent += "</div></body></html>"
f = open(self.getCurrentProjPath() + '/PT Manager Report.html', 'w')
f.writelines(htmlContent)
f.close()
return self.getCurrentProjPath() + '/PT Manager Report.html'
def newlineToBR(self,string):
return "<br />".join(string.split("\n"))
def getFileContent(self,path):
f = open(path, "rb")
content = f.read()
f.close()
return content
def convertVulntoTable(self, number, name, severity, description, mitigation, request = "None", response = "None", images = "None"):
return """<div style="width: 100%%;height: 30px;text-align: center;background-color:#E0E0E0;font-size: 17px;font-weight: bold;color: #000;padding-top: 10px;">%s <a href="javascript:divHideShow('Table_%s');" style="color:#191970">(OPEN / CLOSE)</a></div>
<div id="Table_%s" style="display: none;">
<table width="100%%" cellspacing="0" cellpadding="0" style="margin: 0px auto;text-align: left;border-top: 0px;">
<tr>
<td>
<div style="font-size: 16px;font-weight: bold;">
<span style="color:#000000">Threat Level: </span>
<span style="color:#8b8989">%s</span>
</td>
</tr>
<tr>
<td>
<div style="font-size: 16px;font-weight: bold;">
<span style="color:#000000">Description</span>
<a href="javascript:divHideShow('Table_%s_Command_03');" style="color:#191970">OPEN / CLOSE >>></a>
</div>
<div id="Table_%s_Command_03" style="display: none;margin-top: 25px;">
%s
</div>
</td>
</tr>
<tr>
<td>
<div style="font-size: 16px;font-weight: bold;">
<span style="color:#000000">Mitigration</span>
<a href="javascript:divHideShow('Table_%s_Command_04');" style="color:#191970">OPEN / CLOSE >>></a>
</div>
<div id="Table_%s_Command_04" style="display: none;margin-top: 25px;">
%s
<b>
</td>
</tr>
<tr>
<td>
<div style="font-size: 16px;font-weight: bold;">
<span style="color:#000000">Request</span>
<a href="javascript:divHideShow('Table_%s_Command_05');" style="color:#191970">OPEN / CLOSE >>></a>
</div>
<div id="Table_%s_Command_05" style="display: none;margin-top: 25px;">
%s
<b>
</td>
</tr>
<tr>
<td>
<div style="font-size: 16px;font-weight: bold;">
<span style="color:#000000">Response</span>
<a href="javascript:divHideShow('Table_%s_Command_06');" style="color:#191970">OPEN / CLOSE >>></a>
</div>
<div id="Table_%s_Command_06" style="display: none;margin-top: 25px;">
%s
<b>
</td>
</tr>
<tr>
<td>
<div style="font-size: 16px;font-weight: bold;">
<span style="color:#000000">Images</span>
<a href="javascript:divHideShow('Table_%s_Command_07');" style="color:#191970">OPEN / CLOSE >>></a>
</div>
<div id="Table_%s_Command_07" style="display: none;margin-top: 25px;">
%s
<b>
</td>
</tr>
</table>
</div><br><br>""" % (name,number,number,severity,number,number,description,number,number,mitigation,number,number,request,number,number,response,number,number,images)
def clearVulnerabilityTab(self, rmVuln=True):
if rmVuln:
self.vulnName.setText("")
self.descriptionString.setText("")
self.mitigationStr.setText("")
self.colorCombo.setSelectedIndex(0)
self.threatLevel.setSelectedIndex(0)
self.screenshotsList.clear()
self.addButton.setText("Add")
self.firstPic.setIcon(None)
def saveRequestResponse(self, type, requestResponse, vulnName):
path = self.getVulnReqResPath(type,vulnName)
f = open(path, 'wb')
f.write(requestResponse)
f.close()
def openProj(self, event):
os.system('explorer ' + self.projPath.getText())
def getVulnReqResPath(self, requestOrResponse, vulnName):
return self.getCurrentProjPath() + "/" + self.clearStr(vulnName) + "/"+requestOrResponse+"_" + self.clearStr(vulnName)
def htmlEscape(self,data):
return data.replace('&', '&').replace('<', '<').replace('>', '>').replace('"', '"').replace("'", ''')
def generateReportFromDocxTemplate(self, zipname, newZipName, filename):
newZipName = self.getCurrentProjPath() + "/" + newZipName
with zipfile.ZipFile(zipname, 'r') as zin:
with zipfile.ZipFile(newZipName, 'w') as zout:
zout.comment = zin.comment
for item in zin.infolist():
if item.filename != filename:
zout.writestr(item, zin.read(item.filename))
else:
xml_content = zin.read(item.filename)
result = re.findall("(.*)<w:body>(?:.*)<\/w:body>(.*)",xml_content)[0]
newXML = result[0]
templateBody = re.findall("<w:body>(.*)<\/w:body>", xml_content)[0]
newBody = ""
for i in range(0,self._log.size()):
tmp = templateBody
tmp = tmp.replace("$vulnerability", self.htmlEscape(self._log.get(i).getName()))
tmp = tmp.replace("$severity", self.htmlEscape(self._log.get(i).getSeverity()))
tmp = tmp.replace("$description", self.htmlEscape(self._log.get(i).getDescription()))
tmp = tmp.replace("$mitigation", self.htmlEscape(self._log.get(i).getMitigation()))
newBody = newBody + tmp
newXML = newXML + newBody
newXML = newXML + result[1]
with zipfile.ZipFile(newZipName, mode='a', compression=zipfile.ZIP_DEFLATED) as zf:
zf.writestr(filename, newXML)
return newZipName
def chooseProjPath(self, event):
self.chooser.setDialogTitle("Select target directory")
self.chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
returnVal = self.chooser.showOpenDialog(None)
if returnVal == JFileChooser.APPROVE_OPTION:
projPath = str(self.chooser.getSelectedFile()) + "/PTManager"
os.makedirs(projPath)
self.projPath.setText(projPath)
def reloadProjects(self):
self.currentProject.setModel(DefaultComboBoxModel(self.config.options('projects')))
def rmProj(self, event):
if self.popUpAreYouSure() == JOptionPane.YES_OPTION:
self._requestViewer.setMessage("None", False)
self._responseViewer.setMessage("None", False)
shutil.rmtree(self.projPath.getText())
self.config.remove_option('projects',self.currentProject.getSelectedItem())
self.reloadProjects()
self.currentProject.setSelectedIndex(0)
self.loadVulnerabilities(self.projPath.getText())
def popup(self,msg):
JOptionPane.showMessageDialog(None,msg)
def addProj(self, event):
projPath = self.projPath.getText()
if projPath == None or projPath == "":
self.popup("Please select path")
return
self.config.set('projects', self.projName.getText(), projPath)
self.saveCfg()
xml = ET.Element('project')
name = ET.SubElement(xml, "name")
path = ET.SubElement(xml, "path")
details = ET.SubElement(xml, "details")
autoSaveMode = ET.SubElement(xml, "autoSaveMode")
name.text = self.projName.getText()
path.text = projPath
details.text = self.projDetails.getText()
autoSaveMode.text = str(self.autoSave.isSelected())
tree = ET.ElementTree(xml)
try:
tree.write(self.getCurrentProjPath()+'/project.xml')
except:
self.popup("Invalid path")
return
self.reloadProjects()
self.clearVulnerabilityTab()
self.clearList(None)
self.currentProject.getModel().setSelectedItem(self.projName.getText())
def resize(self, image, width, height):
bi = BufferedImage(width, height, BufferedImage.TRANSLUCENT)
g2d = bi.createGraphics()
g2d.addRenderingHints(RenderingHints(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY))
g2d.drawImage(image, 0, 0, width, height, None)
g2d.dispose()
return bi;
def clearStr(self, var):
return var.replace(" " , "_").replace("\\" , "").replace("/" , "").replace(":" , "").replace("*" , "").replace("?" , "").replace("\"" , "").replace("<" , "").replace(">" , "").replace("|" , "").replace("(" , "").replace(")" , "")
def popUpAreYouSure(self):
dialogResult = JOptionPane.showConfirmDialog(None,"Are you sure?","Warning",JOptionPane.YES_NO_OPTION)
if dialogResult == 0:
return 0
return 1
def removeSS(self,event):
if self.popUpAreYouSure() == JOptionPane.YES_OPTION:
os.remove(self.getCurrentVulnPath() + "/" + self.ssList.getSelectedValue())
self.ssList.getModel().remove(self.ssList.getSelectedIndex())
self.firstPic.setIcon(ImageIcon(None))
# check if there is images and select the first one
# bug in linux
def addSS(self,event):
clipboard = Toolkit.getDefaultToolkit().getSystemClipboard()
try:
image = clipboard.getData(DataFlavor.imageFlavor)
except:
self.popup("Clipboard not contains image")
return
vulnPath = self.projPath.getText() + "/" + self.clearStr(self.vulnName.getText())
if not os.path.exists(vulnPath):
os.makedirs(vulnPath)
name = self.clearStr(self.vulnName.getText()) + str(random.randint(1, 99999))+".jpg"
fileName = self.projPath.getText()+"/"+ self.clearStr(self.vulnName.getText()) + "/" + name
file = File(fileName)
bufferedImage = BufferedImage(image.getWidth(None), image.getHeight(None), BufferedImage.TYPE_INT_RGB);
g = bufferedImage.createGraphics();
g.drawImage(image, 0, 0, bufferedImage.getWidth(), bufferedImage.getHeight(), Color.WHITE, None);
ImageIO.write(bufferedImage, "jpg", file)
self.addVuln(self)
self.ssList.setSelectedValue(name,True)
def rmVuln(self, event):
if self.popUpAreYouSure() == JOptionPane.YES_OPTION:
self._requestViewer.setMessage("None", False)
self._responseViewer.setMessage("None", False)
shutil.rmtree(self.getCurrentVulnPath())
self.clearVulnerabilityTab()
self.loadVulnerabilities(self.getCurrentProjPath())
def addVuln(self, event):
if self.colorCombo.getSelectedItem() == "Color:":
colorTxt = None
else:
colorTxt = self.colorCombo.getSelectedItem()
self._lock.acquire()
row = self._log.size()
vulnObject = vulnerability(self.vulnName.getText(),self.threatLevel.getSelectedItem(),self.descriptionString.getText(),self.mitigationStr.getText() ,colorTxt)
self._log.add(vulnObject)
self.fireTableRowsInserted(row, row)
self._lock.release()
vulnPath = self.projPath.getText() + "/" + self.clearStr(self.vulnName.getText())
if not os.path.exists(vulnPath):
os.makedirs(vulnPath)
xml = ET.Element('vulnerability')
name = ET.SubElement(xml, "name")
severity = ET.SubElement(xml, "severity")
description = ET.SubElement(xml, "description")
mitigation = ET.SubElement(xml, "mitigation")
color = ET.SubElement(xml, "color")
name.text = self.vulnName.getText()
severity.text = self.threatLevel.getSelectedItem()
description.text = self.descriptionString.getText()
mitigation.text = self.mitigationStr.getText()
color.text = colorTxt
tree = ET.ElementTree(xml)
tree.write(vulnPath+'/vulnerability.xml')
self.loadVulnerabilities(self.getCurrentProjPath())
self.loadVulnerability(vulnObject)
def vulnNameChanged(self):
if os.path.exists(self.getCurrentVulnPath()) and self.vulnName.getText() != "":
self.addButton.setText("Update")
elif self.addButton.getText() != "Add":
options = ["Create a new vulnerability", "Change current vulnerability name"]
n = JOptionPane.showOptionDialog(None,
"Would you like to?",
"Vulnerability Name",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE,
None,
options,
options[0]);
if n == 0:
self.clearVulnerabilityTab(False)
self.addButton.setText("Add")
else:
newName = JOptionPane.showInputDialog(
None,
"Enter new name:",
"Vulnerability Name",
JOptionPane.PLAIN_MESSAGE,
None,
None,
self.vulnName.getText())
row = self.logTable.getSelectedRow()
old = self.logTable.getValueAt(row,1)
self.changeVulnName(newName,old)
def changeVulnName(self,new,old):
newpath = self.getCurrentProjPath() + "/" + new
oldpath = self.getCurrentProjPath() + "/" + old
os.rename(oldpath,newpath)
self.changeCurrentVuln(new,0, newpath + "/vulnerability.xml")
def getCurrentVulnPath(self):
return self.projPath.getText() + "/" + self.clearStr(self.vulnName.getText())
def getCurrentProjPath(self):
return self.projPath.getText()
def loadSS(self, imgPath):
image = ImageIO.read(File(imgPath))
if image.getWidth() <= 550 and image.getHeight() <= 400:
self.firstPic.setIcon(ImageIcon(image))
self.firstPic.setSize(image.getWidth(),image.getHeight())
else:
self.firstPic.setIcon(ImageIcon(self.resize(image,550, 400)))
self.firstPic.setSize(550,400)
def clearProjectTab(self):
self.projPath.setText("")
self.projDetails.setText("")
def clearList(self, event):
self._lock.acquire()
self._log = ArrayList()
row = self._log.size()
self.fireTableRowsInserted(row, row)
self._lock.release()
#
# implement IContextMenuFactory
#
def createMenuItems(self, invocation):
responses = invocation.getSelectedMessages();
if responses > 0:
ret = LinkedList()
requestMenuItem = JMenuItem("Send to PT Manager");
requestMenuItem.addActionListener(handleMenuItems(self,responses[0], "request"))
ret.add(requestMenuItem);
return(ret);
return null;
#
# implement ITab
#
def getTabCaption(self):
return "PT Manager"
def getUiComponent(self):
return self._splitpane
#
# extend AbstractTableModel
#
def getRowCount(self):
try:
return self._log.size()
except:
return 0
def getColumnCount(self):
return 3
def getColumnName(self, columnIndex):
if columnIndex == 0:
return "#"
if columnIndex == 1:
return "Vulnerability Name"
if columnIndex == 2:
return "Threat Level"
return ""
def getValueAt(self, rowIndex, columnIndex):
vulnObject = self._log.get(rowIndex)
if columnIndex == 0:
return rowIndex+1
if columnIndex == 1:
return vulnObject.getName()
if columnIndex == 2:
return vulnObject.getSeverity()
if columnIndex == 3:
return vulnObject.getMitigation()
if columnIndex == 4:
return vulnObject.getColor()
return ""
def changeCurrentVuln(self,value,fieldNumber, xmlPath = "def"):
if xmlPath == "def":
xmlPath = self.getCurrentVulnPath() + "/vulnerability.xml"
document = self.getXMLDoc(xmlPath)
nodeList = document.getDocumentElement().getChildNodes()
nodeList.item(fieldNumber).setTextContent(value)
self.saveXMLDoc(document, xmlPath)
self.loadVulnerabilities(self.getCurrentProjPath())
def loadVulnerability(self, vulnObject):
self.addButton.setText("Update")
self.vulnName.setText(vulnObject.getName())
self.threatLevel.setSelectedItem(vulnObject.getSeverity())
self.descriptionString.setText(vulnObject.getDescription())
self.mitigationStr.setText(vulnObject.getMitigation())
if vulnObject.getColor() == "" or vulnObject.getColor() == None:
self.colorCombo.setSelectedItem("Color:")
else:
self.colorCombo.setSelectedItem(vulnObject.getColor())
self.screenshotsList.clear()
for fileName in os.listdir(self.projPath.getText()+"/"+self.clearStr(vulnObject.getName())):
if fileName.endswith(".jpg"):
self.screenshotsList.addElement(fileName)
imgPath = self.projPath.getText()+"/"+self.clearStr(vulnObject.getName())+'/'+fileName
# imgPath = imgPath.replace("/","//")
self.loadSS(imgPath)
if (self.screenshotsList.getSize() == 0):
self.firstPic.setIcon(None)
else:
self.ssList.setSelectedIndex(0)
path = self.getVulnReqResPath("request",vulnObject.getName())
if os.path.exists(path):
f = self.getFileContent(path)
self._requestViewer.setMessage(f, False)
else:
self._requestViewer.setMessage("None", False)
path = self.getVulnReqResPath("response",vulnObject.getName())
if os.path.exists(path):
f = self.getFileContent(path)
self._responseViewer.setMessage(f, False)
else:
self._responseViewer.setMessage("None", False)
f2_txt2.setText("")
del gvars['path_original_image']
del gvars['path_label_image']
def f3_clic_finish(event): # Finish
print "Click Finish"
gvars["workingImage"].close() # When going back, close the current picture
frame3.dispose()
# Number of pixels to erode
lbl1 = JLabel("Number of pixels to erode")
lbl1.setBounds(110,30,160,20)
f3_txt1 = JTextField(10)
f3_txt1.setBounds(270, 30, 60,20)
f3_txt1.setText(str(0))
# Button Update
f3_btn_update = JButton("Update ROIs", actionPerformed = f3_clic_update)
f3_btn_update.setBounds(60,70,150,20)
# Button Save Rois
f3_btn_saveRois = JButton("Save ROIs", actionPerformed = f3_clic_SaveROIs)
f3_btn_saveRois.setBounds(250,70,150,20)
# Button Previous - Choose Parameters
f3_btn_params = JButton("Set measurements", actionPerformed = f3_clic_measurements)
f3_btn_params.setBounds(60,110,150,20)
# Button Previous - Save Table
f3_btn_saveTable = JButton("Save CSV Table", actionPerformed = f3_clic_saveTable)
class NewZoneDialog(JDialog, ActionListener, WindowListener):
"""Dialog for favourite zone editing
"""
def __init__(self, parent, title, modal, app):
from java.awt import CardLayout
self.app = app
border = BorderFactory.createEmptyBorder(5, 7, 7, 7)
self.getContentPane().setBorder(border)
self.setLayout(BoxLayout(self.getContentPane(), BoxLayout.Y_AXIS))
self.FAVAREALAYERNAME = "Favourite zone editing"
info = JLabel(self.app.strings.getString("Create_a_new_favourite_zone"))
info.setAlignmentX(Component.LEFT_ALIGNMENT)
#Name
nameLbl = JLabel(self.app.strings.getString("fav_zone_name"))
self.nameTextField = JTextField(20)
self.nameTextField.setMaximumSize(self.nameTextField.getPreferredSize())
self.nameTextField.setToolTipText(self.app.strings.getString("fav_zone_name_tooltip"))
namePanel = JPanel()
namePanel.setLayout(BoxLayout(namePanel, BoxLayout.X_AXIS))
namePanel.add(nameLbl)
namePanel.add(Box.createHorizontalGlue())
namePanel.add(self.nameTextField)
#Country
countryLbl = JLabel(self.app.strings.getString("fav_zone_country"))
self.countryTextField = JTextField(20)
self.countryTextField.setMaximumSize(self.countryTextField.getPreferredSize())
self.countryTextField.setToolTipText(self.app.strings.getString("fav_zone_country_tooltip"))
countryPanel = JPanel()
countryPanel.setLayout(BoxLayout(countryPanel, BoxLayout.X_AXIS))
countryPanel.add(countryLbl)
countryPanel.add(Box.createHorizontalGlue())
countryPanel.add(self.countryTextField)
#Type
modeLbl = JLabel(self.app.strings.getString("fav_zone_type"))
RECTPANEL = "rectangle"
POLYGONPANEL = "polygon"
BOUNDARYPANEL = "boundary"
self.modesStrings = [RECTPANEL, POLYGONPANEL, BOUNDARYPANEL]
modesComboModel = DefaultComboBoxModel()
for i in (self.app.strings.getString("rectangle"),
self.app.strings.getString("delimited_by_a_closed_way"),
self.app.strings.getString("delimited_by_an_administrative_boundary")):
modesComboModel.addElement(i)
self.modesComboBox = JComboBox(modesComboModel,
actionListener=self,
editable=False)
#- Rectangle
self.rectPanel = JPanel()
self.rectPanel.setLayout(BoxLayout(self.rectPanel, BoxLayout.Y_AXIS))
capturePane = JPanel()
capturePane.setLayout(BoxLayout(capturePane, BoxLayout.X_AXIS))
capturePane.setAlignmentX(Component.LEFT_ALIGNMENT)
josmP = JPanel()
self.captureRBtn = JRadioButton(self.app.strings.getString("capture_area"))
self.captureRBtn.addActionListener(self)
self.captureRBtn.setSelected(True)
self.bboxFromJosmBtn = JButton(self.app.strings.getString("get_current_area"),
actionPerformed=self.on_bboxFromJosmBtn_clicked)
self.bboxFromJosmBtn.setToolTipText(self.app.strings.getString("get_capture_area_tooltip"))
josmP.add(self.bboxFromJosmBtn)
capturePane.add(self.captureRBtn)
capturePane.add(Box.createHorizontalGlue())
capturePane.add(self.bboxFromJosmBtn)
manualPane = JPanel()
manualPane.setLayout(BoxLayout(manualPane, BoxLayout.X_AXIS))
manualPane.setAlignmentX(Component.LEFT_ALIGNMENT)
self.manualRBtn = JRadioButton(self.app.strings.getString("use_this_bbox"))
self.manualRBtn.addActionListener(self)
self.bboxTextField = JTextField(20)
self.bboxTextField.setMaximumSize(self.bboxTextField.getPreferredSize())
self.bboxTextField.setToolTipText(self.app.strings.getString("fav_bbox_tooltip"))
self.bboxTextFieldDefaultBorder = self.bboxTextField.getBorder()
self.bboxTextField.getDocument().addDocumentListener(TextListener(self))
manualPane.add(self.manualRBtn)
manualPane.add(Box.createHorizontalGlue())
manualPane.add(self.bboxTextField)
group = ButtonGroup()
group.add(self.captureRBtn)
group.add(self.manualRBtn)
previewPane = JPanel()
previewPane.setLayout(BoxLayout(previewPane, BoxLayout.X_AXIS))
previewPane.setAlignmentX(Component.LEFT_ALIGNMENT)
bboxPreviewInfo = JTextField(self.app.strings.getString("coordinates"),
editable=0,
border=None)
bboxPreviewInfo.setMaximumSize(bboxPreviewInfo.getPreferredSize())
self.bboxPreviewTextField = JTextField(20,
editable=0,
border=None)
self.bboxPreviewTextField.setMaximumSize(self.bboxPreviewTextField.getPreferredSize())
previewPane.add(bboxPreviewInfo)
previewPane.add(Box.createHorizontalGlue())
previewPane.add(self.bboxPreviewTextField)
self.rectPanel.add(capturePane)
self.rectPanel.add(Box.createRigidArea(Dimension(0, 10)))
self.rectPanel.add(manualPane)
self.rectPanel.add(Box.createRigidArea(Dimension(0, 20)))
self.rectPanel.add(previewPane)
#- Polygon (closed way) drawn by hand
self.polygonPanel = JPanel(BorderLayout())
self.polygonPanel.setLayout(BoxLayout(self.polygonPanel, BoxLayout.Y_AXIS))
polyInfo = JLabel("<html>%s</html>" % self.app.strings.getString("polygon_info"))
polyInfo.setFont(polyInfo.getFont().deriveFont(Font.ITALIC))
polyInfo.setAlignmentX(Component.LEFT_ALIGNMENT)
editPolyPane = JPanel()
editPolyPane.setAlignmentX(Component.LEFT_ALIGNMENT)
editPolyBtn = JButton(self.app.strings.getString("create_fav_layer"),
actionPerformed=self.create_new_zone_editing_layer)
editPolyBtn.setToolTipText(self.app.strings.getString("create_fav_layer_tooltip"))
editPolyPane.add(editPolyBtn)
self.polygonPanel.add(polyInfo)
self.polygonPanel.add(Box.createRigidArea(Dimension(0, 15)))
self.polygonPanel.add(editPolyPane)
self.polygonPanel.add(Box.createRigidArea(Dimension(0, 15)))
#- Administrative Boundary
self.boundaryPanel = JPanel()
self.boundaryPanel.setLayout(BoxLayout(self.boundaryPanel, BoxLayout.Y_AXIS))
boundaryInfo = JLabel("<html>%s</html>" % app.strings.getString("boundary_info"))
boundaryInfo.setFont(boundaryInfo.getFont().deriveFont(Font.ITALIC))
boundaryInfo.setAlignmentX(Component.LEFT_ALIGNMENT)
boundaryTagsPanel = JPanel(GridLayout(3, 3, 5, 5))
boundaryTagsPanel.setAlignmentX(Component.LEFT_ALIGNMENT)
boundaryTagsPanel.add(JLabel("name ="))
self.nameTagTextField = JTextField(20)
boundaryTagsPanel.add(self.nameTagTextField)
boundaryTagsPanel.add(JLabel("admin_level ="))
self.adminLevelTagTextField = JTextField(20)
self.adminLevelTagTextField.setToolTipText(self.app.strings.getString("adminLevel_tooltip"))
boundaryTagsPanel.add(self.adminLevelTagTextField)
boundaryTagsPanel.add(JLabel(self.app.strings.getString("other_tag")))
self.optionalTagTextField = JTextField(20)
self.optionalTagTextField.setToolTipText("key=value")
boundaryTagsPanel.add(self.optionalTagTextField)
downloadBoundariesPane = JPanel()
downloadBoundariesPane.setAlignmentX(Component.LEFT_ALIGNMENT)
downloadBoundariesBtn = JButton(self.app.strings.getString("download_boundary"),
actionPerformed=self.on_downloadBoundariesBtn_clicked)
downloadBoundariesBtn.setToolTipText(self.app.strings.getString("download_boundary_tooltip"))
downloadBoundariesPane.add(downloadBoundariesBtn)
self.boundaryPanel.add(boundaryInfo)
self.boundaryPanel.add(Box.createRigidArea(Dimension(0, 15)))
self.boundaryPanel.add(boundaryTagsPanel)
self.boundaryPanel.add(Box.createRigidArea(Dimension(0, 10)))
self.boundaryPanel.add(downloadBoundariesPane)
self.editingPanels = {"rectangle": self.rectPanel,
"polygon": self.polygonPanel,
"boundary": self.boundaryPanel}
#Main buttons
self.okBtn = JButton(self.app.strings.getString("OK"),
ImageProvider.get("ok"),
actionPerformed=self.on_okBtn_clicked)
self.cancelBtn = JButton(self.app.strings.getString("cancel"),
ImageProvider.get("cancel"),
actionPerformed=self.close_dialog)
self.previewBtn = JButton(self.app.strings.getString("Preview_zone"),
actionPerformed=self.on_previewBtn_clicked)
self.previewBtn.setToolTipText(self.app.strings.getString("preview_zone_tooltip"))
okBtnSize = self.okBtn.getPreferredSize()
viewBtnSize = self.previewBtn.getPreferredSize()
viewBtnSize.height = okBtnSize.height
self.previewBtn.setPreferredSize(viewBtnSize)
#layout
self.add(info)
self.add(Box.createRigidArea(Dimension(0, 15)))
namePanel.setAlignmentX(Component.LEFT_ALIGNMENT)
self.add(namePanel)
self.add(Box.createRigidArea(Dimension(0, 15)))
countryPanel.setAlignmentX(Component.LEFT_ALIGNMENT)
self.add(countryPanel)
self.add(Box.createRigidArea(Dimension(0, 15)))
modeLbl.setAlignmentX(Component.LEFT_ALIGNMENT)
self.add(modeLbl)
self.add(Box.createRigidArea(Dimension(0, 5)))
self.add(self.modesComboBox)
self.modesComboBox.setAlignmentX(Component.LEFT_ALIGNMENT)
self.add(Box.createRigidArea(Dimension(0, 15)))
self.configPanel = JPanel(CardLayout())
self.configPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5))
self.configPanel.add(self.rectPanel, RECTPANEL)
self.configPanel.add(self.polygonPanel, POLYGONPANEL)
self.configPanel.add(self.boundaryPanel, BOUNDARYPANEL)
self.configPanel.setAlignmentX(Component.LEFT_ALIGNMENT)
self.add(self.configPanel)
buttonsPanel = JPanel()
buttonsPanel.add(self.okBtn)
buttonsPanel.add(self.cancelBtn)
buttonsPanel.add(self.previewBtn)
buttonsPanel.setAlignmentX(Component.LEFT_ALIGNMENT)
self.add(buttonsPanel)
self.addWindowListener(self)
self.pack()
def update_gui_from_preferences(self):
self.nameTextField.setText(self.app.newZone.name)
#Reset rectangle mode
bboxStr = ",".join(["%0.4f" % x for x in self.app.newZone.bbox])
self.bboxTextField.setText(bboxStr)
self.bboxPreviewTextField.setText(bboxStr)
self.bboxFromJosmBtn.setEnabled(True)
self.bboxTextField.setEnabled(False)
#Reset polygon mode
self.polygonAsString = ""
#Reset boundary mode
self.boundaryAsString = ""
self.modesComboBox.setSelectedIndex(0)
def actionPerformed(self, e):
#Show the panel for configuring the favourite area of the
#selected type
if e.getSource() == self.modesComboBox:
cl = self.configPanel.getLayout()
selectedMode = self.modesStrings[self.modesComboBox.selectedIndex]
cl.show(self.configPanel, selectedMode)
#Activate bbox input for rectangular favourite zone mode
elif e.getSource() == self.captureRBtn:
self.bboxFromJosmBtn.setEnabled(True)
self.bboxTextField.setEnabled(False)
else:
self.bboxFromJosmBtn.setEnabled(False)
self.bboxTextField.setEnabled(True)
def on_bboxFromJosmBtn_clicked(self, widget):
"""Read bbox currently shown in JOSM
"""
bbox = self.app.get_frame_bounds()
self.bboxPreviewTextField.setText(",".join(["%0.4f" % x for x in bbox]))
### Manage layer for creating a new favourite zone from polygon or boundary
def create_new_zone_editing_layer(self, e=None):
"""Open a new dataset where the user can draw a closed way to
delimit the favourite area
"""
layer = self.get_new_zone_editing_layer()
if layer is not None:
self.app.mv.setActiveLayer(layer)
else:
Main.main.addLayer(OsmDataLayer(DataSet(), self.FAVAREALAYERNAME, None))
Main.main.parent.toFront()
def get_new_zone_editing_layer(self):
"""Check if the layer for editing the favourite area yet exists
"""
for layer in self.app.mv.getAllLayers():
if layer.getName() == self.FAVAREALAYERNAME:
return layer
return None
def remove_new_zone_editing_layer(self):
layer = self.get_new_zone_editing_layer()
if layer is not None:
self.app.mv.removeLayer(layer)
def on_zone_edited(self):
"""Read ways that delimit the favourite area and convert them to
jts geometry
"""
if self.modesComboBox.getSelectedIndex() == 0:
mode = "rectangle"
elif self.modesComboBox.getSelectedIndex() == 1:
mode = "polygon"
elif self.modesComboBox.getSelectedIndex() == 2:
mode = "boundary"
if mode in ("polygon", "boundary"):
layer = self.get_new_zone_editing_layer()
if layer is not None:
self.app.mv.setActiveLayer(layer)
else:
if mode == "polygon":
msg = self.app.strings.getString("polygon_fav_layer_missing_msg")
else:
msg = self.app.strings.getString("boundary_fav_layer_missing_msg")
JOptionPane.showMessageDialog(self,
msg,
self.app.strings.getString("Warning"),
JOptionPane.WARNING_MESSAGE)
return
dataset = self.app.mv.editLayer.data
areaWKT = self.read_area_from_osm_ways(mode, dataset)
if areaWKT is None:
print "I could not read the new favourite area."
else:
if mode == "polygon":
self.polygonAsString = areaWKT
else:
self.boundaryAsString = areaWKT
return mode
def read_area_from_osm_ways(self, mode, dataset):
"""Read way in favourite area editing layer and convert them to
WKT
"""
converter = JTSConverter(False)
lines = [converter.convert(way) for way in dataset.ways]
polygonizer = Polygonizer()
polygonizer.add(lines)
polygons = polygonizer.getPolygons()
multipolygon = GeometryFactory().createMultiPolygon(list(polygons))
multipolygonWKT = WKTWriter().write(multipolygon)
if multipolygonWKT == "MULTIPOLYGON EMPTY":
if mode == "polygon":
msg = self.app.strings.getString("empty_ways_polygon_msg")
else:
msg = self.app.strings.getString("empty_ways_boundaries_msg")
JOptionPane.showMessageDialog(self,
msg,
self.app.strings.getString("Warning"),
JOptionPane.WARNING_MESSAGE)
return
return multipolygonWKT
def on_downloadBoundariesBtn_clicked(self, e):
"""Download puter ways of administrative boundaries from
Overpass API
"""
adminLevel = self.adminLevelTagTextField.getText()
name = self.nameTagTextField.getText()
optional = self.optionalTagTextField.getText()
if (adminLevel, name, optional) == ("", "", ""):
JOptionPane.showMessageDialog(self,
self.app.strings.getString("enter_a_tag_msg"),
self.app.strings.getString("Warning"),
JOptionPane.WARNING_MESSAGE)
return
optTag = ""
if optional.find("=") != -1:
if len(optional.split("=")) == 2:
key, value = optional.split("=")
optTag = '["%s"="%s"]' % (URLEncoder.encode(key, "UTF-8"),
URLEncoder.encode(value.replace(" ", "%20"), "UTF-8"))
self.create_new_zone_editing_layer()
overpassurl = 'http://127.0.0.1:8111/import?url='
overpassurl += 'http://overpass-api.de/api/interpreter?data='
overpassquery = 'relation["admin_level"="%s"]' % adminLevel
overpassquery += '["name"="%s"]' % URLEncoder.encode(name, "UTF-8")
overpassquery += '%s;(way(r:"outer");node(w););out meta;' % optTag
overpassurl += overpassquery.replace(" ", "%20")
print overpassurl
self.app.send_to_josm(overpassurl)
### Buttons ############################################################
def create_new_zone(self, mode):
"""Read data entered on gui and create a new zone
"""
name = self.nameTextField.getText()
country = self.countryTextField.getText().upper()
#error: name
if name.replace(" ", "") == "":
JOptionPane.showMessageDialog(self,
self.app.strings.getString("missing_name_warning"),
self.app.strings.getString("missing_name_warning_title"),
JOptionPane.WARNING_MESSAGE)
return False
if name in [z.name for z in self.app.tempZones]:
JOptionPane.showMessageDialog(self,
self.app.strings.getString("duplicate_name_warning"),
self.app.strings.getString("duplicate_name_warning_title"),
JOptionPane.WARNING_MESSAGE)
return False
#zone type
zType = mode
#error: geometry type not defined
if zType == "polygon" and self.polygonAsString == ""\
or zType == "boundary" and self.boundaryAsString == "":
JOptionPane.showMessageDialog(self,
self.app.strings.getString("zone_not_correctly_build_warning"),
self.app.strings.getString("zone_not_correctly_build_warning_title"),
JOptionPane.WARNING_MESSAGE)
return False
#geometry string
if zType == "rectangle":
geomString = self.bboxPreviewTextField.getText()
elif zType == "polygon":
geomString = self.polygonAsString
else:
geomString = self.boundaryAsString
self.app.newZone = Zone(self.app, name, zType, geomString, country)
#self.app.newZone.print_info()
return True
def on_okBtn_clicked(self, event):
"""Add new zone to temp zones
"""
mode = self.on_zone_edited()
if self.create_new_zone(mode):
self.app.tempZones.append(self.app.newZone)
self.app.preferencesFrame.zonesTable.getModel().addRow([self.app.newZone.country,
self.app.newZone.icon,
self.app.newZone.name])
maxIndex = len(self.app.tempZones) - 1
self.app.preferencesFrame.zonesTable.setRowSelectionInterval(maxIndex,
maxIndex)
self.close_dialog()
self.app.preferencesFrame.check_removeBtn_status()
self.app.preferencesFrame.zonesTable.scrollRectToVisible(
self.app.preferencesFrame.zonesTable.getCellRect(
self.app.preferencesFrame.zonesTable.getRowCount() - 1, 0, True))
def on_previewBtn_clicked(self, e):
"""Show the favourite area on a map
"""
mode = self.on_zone_edited()
if not self.create_new_zone(mode):
return
zone = self.app.newZone
if zone.zType == "rectangle":
wktString = zone.bbox_to_wkt_string()
else:
wktString = zone.wktGeom
script = '/*http://stackoverflow.com/questions/11954401/wkt-and-openlayers*/'
script += '\nfunction init() {'
script += '\n var map = new OpenLayers.Map({'
script += '\n div: "map",'
script += '\n projection: new OpenLayers.Projection("EPSG:900913"),'
script += '\n displayProjection: new OpenLayers.Projection("EPSG:4326"),'
script += '\n layers: ['
script += '\n new OpenLayers.Layer.OSM()'
script += '\n ]'
script += '\n });'
script += '\n var wkt = new OpenLayers.Format.WKT();'
script += '\n var polygonFeature = wkt.read("%s");' % wktString
script += '\n var vectors = new OpenLayers.Layer.Vector("Favourite area");'
script += '\n map.addLayer(vectors);'
script += '\n polygonFeature.geometry.transform(map.displayProjection, map.getProjectionObject());'
script += '\n vectors.addFeatures([polygonFeature]);'
script += '\n map.zoomToExtent(vectors.getDataExtent());'
script += '\n};'
scriptFile = open(File.separator.join([self.app.SCRIPTDIR,
"html",
"script.js"]), "w")
scriptFile.write(script)
scriptFile.close()
OpenBrowser.displayUrl(File.separator.join([self.app.SCRIPTDIR,
"html",
"favourite_area.html"]))
def windowClosing(self, windowEvent):
self.close_dialog()
def close_dialog(self, e=None):
#delete favourite zone editing layer if present
self.remove_new_zone_editing_layer()
self.dispose()
self.app.preferencesFrame.setEnabled(True)
self.app.preferencesFrame.toFront()
class BurpExtender(IBurpExtender, IScannerCheck, ITab):
def __init__(self):
self.ext_name = 'AWS Extender'
self.callbacks = None
self.gui_elements = None
self.aws_access_key_inpt = None
self.aws_secret_key_inpt = None
self.aws_session_token_inpt = None
self.gs_access_key_inpt = None
self.gs_secret_key_inpt = None
self.wordlist_path_inpt = None
self.checkbox_inpt = None
self.aws_access_key = ''
self.aws_secret_key = ''
self.aws_session_token = ''
self.gs_access_key = ''
self.gs_secret_key = ''
self.wordlist_path = ''
def registerExtenderCallbacks(self, callbacks):
"""Register extender callbacks."""
self.callbacks = callbacks
# Set the name of the extension
self.callbacks.setExtensionName(self.ext_name)
# Register the extension as a scanner check
self.callbacks.registerScannerCheck(self)
# Build GUI elements
self.gui_elements = self.build_gui()
callbacks.customizeUiComponent(self.gui_elements)
callbacks.addSuiteTab(self)
self.check_loading_issues()
self.reload_config()
def show_errors(self, label):
"""Display error messages."""
top_label = JLabel(label, JLabel.CENTER)
frame = JFrame(self.ext_name)
frame.setSize(550, 300)
frame.setLayout(GridLayout(1, 1))
frame.add(top_label)
frame.setLocationRelativeTo(None)
frame.setVisible(True)
def check_loading_issues(self):
"""Check for any loading issues."""
missing_libs = []
tips = []
label = """<html>
<body style='margin: 10px'>
<b>The following dependencies could not be loaded successfully:</b><br>
<ul><li>%s</li></ul><br>
<b>Tips:</b><br>
<ul><li>%s</li><br></ul>
<b>For detailed information on how to load the plugin, see:</b><br>
<ul>
<li>
<a href='#'>https://github.com/VirtueSecurity/aws-extender#getting-started</a>
</li>
</ul>
</body>
</html>"""
if not RUN_TESTS:
missing_libs.append('boto/boto3')
tips.append(
'Make sure that the boto/boto3 library is installed properly, and\
the right path is specified in the "Folder for loading modules" setting.'
)
try:
CET.fromstring('<test></test>')
except SAXException:
# Try to workaround "http://bugs.jython.org/issue1127"
try:
def xml_parser(**_):
class Parser(object):
def feed(*_):
raise XMLParseError
def close(*_):
return None
return Parser()
CET.XMLParser = xml_parser
except TypeError:
missing_libs.append('SAXParser')
tips.append("""Run Burp Suite using the following command:
<br><code style='background: #f7f7f9; color: red'>$ java -classpath
xercesImpl.jar;burpsuite_pro.jar burp.StartBurp</code>""")
if not missing_libs:
return
label %= ('</li><li>'.join(missing_libs), '</li><li>'.join(tips))
self.show_errors(label)
def build_gui(self):
"""Construct GUI elements."""
panel = JPanel(BorderLayout(3, 3))
panel.setBorder(EmptyBorder(160, 160, 160, 160))
self.aws_access_key_inpt = JTextField(10)
self.aws_secret_key_inpt = JTextField(10)
self.aws_session_token_inpt = JTextField(10)
self.gs_access_key_inpt = JTextField(10)
self.gs_secret_key_inpt = JTextField(10)
self.wordlist_path_inpt = JTextField(10)
self.checkbox_inpt = JCheckBox('Enabled')
save_btn = JButton('Save', actionPerformed=self.save_config)
labels = JPanel(GridLayout(0, 1))
inputs = JPanel(GridLayout(0, 1))
panel.add(labels, BorderLayout.WEST)
panel.add(inputs, BorderLayout.CENTER)
top_label = JLabel('<html><b>Settings</b><br><br></html>')
top_label.setHorizontalAlignment(JLabel.CENTER)
panel.add(top_label, BorderLayout.NORTH)
labels.add(JLabel('AWS Access Key:'))
inputs.add(self.aws_access_key_inpt)
labels.add(JLabel('AWS Secret Key:'))
inputs.add(self.aws_secret_key_inpt)
labels.add(JLabel('AWS Session Key (optional):'))
inputs.add(self.aws_session_token_inpt)
labels.add(JLabel('GS Access Key:'))
inputs.add(self.gs_access_key_inpt)
labels.add(JLabel('GS Secret Key:'))
inputs.add(self.gs_secret_key_inpt)
labels.add(JLabel('Wordlist Filepath (optional):'))
inputs.add(self.wordlist_path_inpt)
labels.add(JLabel('Passive Mode:'))
inputs.add(self.checkbox_inpt)
panel.add(save_btn, BorderLayout.SOUTH)
return panel
def save_config(self, _):
"""Save settings."""
error_message = ''
wordlist_path = self.wordlist_path_inpt.getText()
save_setting = self.callbacks.saveExtensionSetting
save_setting('aws_access_key', self.aws_access_key_inpt.getText())
save_setting('aws_secret_key', self.aws_secret_key_inpt.getText())
save_setting('aws_session_token',
self.aws_session_token_inpt.getText())
save_setting('gs_access_key', self.gs_access_key_inpt.getText())
save_setting('gs_secret_key', self.gs_secret_key_inpt.getText())
save_setting('wordlist_path', wordlist_path)
if self.checkbox_inpt.isSelected():
save_setting('passive_mode', 'True')
else:
save_setting('passive_mode', '')
if wordlist_path and not os.path.isfile(wordlist_path):
error_message = 'Error: Invalid filepath for the "Wordlist Filepath" setting.'
self.show_errors(error_message)
self.reload_config()
def reload_config(self):
"""Reload saved settings."""
global RUN_TESTS
load_setting = self.callbacks.loadExtensionSetting
aws_access_key_val = load_setting('aws_access_key') or ''
aws_secret_key_val = load_setting('aws_secret_key') or ''
aws_session_token_val = load_setting('aws_session_token') or ''
gs_access_key_val = load_setting('gs_access_key') or ''
gs_secret_key_val = load_setting('gs_secret_key') or ''
wordlist_path_val = load_setting('wordlist_path') or ''
checkbox_inpt_val = load_setting('passive_mode')
checkbox_inpt_val = bool(
str(checkbox_inpt_val)) if checkbox_inpt_val else False
if checkbox_inpt_val:
RUN_TESTS = False
else:
RUN_TESTS = True
self.aws_access_key = aws_access_key_val
self.aws_secret_key = aws_secret_key_val
self.aws_session_token = aws_session_token_val
self.gs_access_key = gs_access_key_val
self.gs_secret_key = gs_secret_key_val
self.wordlist_path = wordlist_path_val
self.aws_access_key_inpt.setText(aws_access_key_val)
self.aws_secret_key_inpt.setText(aws_secret_key_val)
self.aws_session_token_inpt.setText(aws_session_token_val)
self.gs_access_key_inpt.setText(gs_access_key_val)
self.gs_secret_key_inpt.setText(gs_secret_key_val)
self.wordlist_path_inpt.setText(wordlist_path_val)
self.checkbox_inpt.setSelected(checkbox_inpt_val)
def getTabCaption(self):
"""Return tab caption."""
return self.ext_name
def getUiComponent(self):
"""Return GUI elements."""
return self.gui_elements
def doPassiveScan(self, request_response):
"""Perform a passive scan."""
scan_issues = []
opts = {
'aws_access_key': self.aws_access_key,
'aws_secret_key': self.aws_secret_key,
'aws_session_token': self.aws_session_token,
'gs_access_key': self.gs_access_key,
'gs_secret_key': self.gs_secret_key,
'wordlist_path': self.wordlist_path
}
bucket_scan = BucketScan(request_response, self.callbacks, opts)
bucket_issues = bucket_scan.check_buckets()
cognito_scan = CognitoScan(request_response, self.callbacks)
cognito_issues = cognito_scan.identify_identity_pools()
scan_issues = bucket_issues + cognito_issues
if len(scan_issues) > 0:
return scan_issues
return None
@staticmethod
def doActiveScan(*_):
pass
@staticmethod
def consolidateDuplicateIssues(existing_issue, new_issue):
"""Eliminate duplicate issues."""
if existing_issue.getIssueDetail() == new_issue.getIssueDetail():
return -1
else:
return 0
class javadocInfo(java.lang.Runnable):
#---------------------------------------------------------------------------
# Name: run()
# Role: Instantiate the user class
# Note: Invoked by the Swing Event Dispatch Thread
#---------------------------------------------------------------------------
def run(self):
#-----------------------------------------------------------------------
# Size the frame to use 1/2 of the screen
#-----------------------------------------------------------------------
screenSize = Toolkit.getDefaultToolkit().getScreenSize()
frameSize = Dimension(screenSize.width >> 1, screenSize.height >> 1)
frame = JFrame('javadocInfo',
size=frameSize,
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
#-----------------------------------------------------------------------
# Reposition the frame to be in the center of the screen
#-----------------------------------------------------------------------
frame.setLocation((screenSize.width - frameSize.width) >> 1,
(screenSize.height - frameSize.height) >> 1)
#-----------------------------------------------------------------------
# Initialize the list to have exactly 1 element
#-----------------------------------------------------------------------
self.List = JList(['One moment please...'],
valueChanged=self.pick,
selectionMode=ListSelectionModel.SINGLE_SELECTION)
#-----------------------------------------------------------------------
# Put the List in a ScrollPane and place it in the middle of a pane
#-----------------------------------------------------------------------
pane = JPanel(layout=BorderLayout())
pane.add(JScrollPane(self.List), BorderLayout.CENTER)
#-----------------------------------------------------------------------
# Add a TextField [for the URL of the selected entry] at the bottom
#-----------------------------------------------------------------------
self.msg = JTextField()
pane.add(self.msg, BorderLayout.SOUTH)
#-----------------------------------------------------------------------
# Add the pane and a scrollable TextArea to a SplitPane in the frame
#-----------------------------------------------------------------------
self.area = JTextArea()
sPane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
pane,
JScrollPane(self.area),
propertyChange=self.propChange)
sPane.setDividerLocation(234)
frame.add(sPane)
#-----------------------------------------------------------------------
# Create a separate thread to locate & proces the remote URL
#-----------------------------------------------------------------------
self.Links = {} # Initialize the Links dictionary
soupTask(
self.List, # The visible JList instance
self.msg, # The message area (JTextField)
JAVADOC_URL, # Remote web page URL to be processed
self.Links # Dictionary of links found
).execute()
frame.setVisible(1)
#---------------------------------------------------------------------------
# Name: pick()
# Role: ListSelectionListener event handler
#---------------------------------------------------------------------------
def pick(self, e):
#-----------------------------------------------------------------------
# Note: Ignore valueIsAdjusting events
#-----------------------------------------------------------------------
if not e.getValueIsAdjusting():
List = self.List
model = List.getModel()
#-------------------------------------------------------------------
# Ignore events for initial "One moment please..." list
#-------------------------------------------------------------------
if model.getSize() > 1:
#---------------------------------------------------------------
# Is an item selected, or not?
#---------------------------------------------------------------
index = List.getSelectedIndex()
if index > -1:
choice = model.elementAt(index)
url = self.Links[choice]
self.msg.setText(url)
textTask(
self.area, # The text area to be updated
url # Remote web page URL to be processed
).execute()
else:
self.msg.setText('Make a selection')
self.area.setText('No item selected')
#---------------------------------------------------------------------------
# Name: propChange()
# Role: PropertyChangeListener event handler for JSplitPane
#---------------------------------------------------------------------------
def propChange(self, pce):
src = pce.getSource() # Should be our JSplitPane
prop = pce.getPropertyName()
if prop == JSplitPane.LAST_DIVIDER_LOCATION_PROPERTY:
curr = src.getDividerLocation()
last = pce.getNewValue()
prev = pce.getOldValue()
print '\nlast: %4d prev: %4d curr: %4d' % (last, prev, curr),
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
class ConsolePanel(Panel):
def __init__(self):
self.console = None
self.outText = None
self.inText = None
self.outTextScroller = None
self.nestedInputPanel = None
self.directoryText = None
Panel.__init__(self, "insets 0 0 0 0")
def sendCommand(self, command):
print str(self)
oldText = self.inText.getText()
self.inText.setText(command)
self.inText.getActionListeners()[0].actionPerformed(None)
self.inText.setText(oldText)
def setDirectoryText(self, dirText):
self.directoryText.setText(dirText)
self.nestedInputPanel.revalidate()
def write_out(self,text):
if not self.outText:
return
self.outText.setText(self.outText.getText() + text)
def initUI(self):
font = Font("Courier New", Font.BOLD, 14)
#create the output text panel
self.outText = JTextArea()
self.outText.setEditable(False)
self.outText.setFont(font)
self.outText.setWrapStyleWord(True)
self.outText.setLineWrap(True)
#self.outText.setLineWrap(True)
#self.outText.setWrapStyleWord(True)
class NoGhostScroller(JScrollPane):
def paintComponent(self, g):
g.setColor(self.getBackground())
g.fillRect(0, 0, self.getWidth(), self.getHeight())
#super(NoGhostScroller, self).paintComponent(g)
self.outTextScroller = JScrollPane(self.outText)
self.outTextScroller.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER)
self.outTextScroller.getVerticalScrollBar().setForeground(Color(255, 0, 0))
#self.outText.setOpaque(False)
self.outText.setBackground(Color(0, 20, 0))
self.outText.setForeground(Color.WHITE)
#self.outTextScroller.setOpaque(False)
self.outTextScroller.setBackground(Color(0, 20, 0))
#self.outText.repaint()
#self.layered = JLayeredPane()
#self.layered.setLayer(self.outTextScroller, 0)
#create the input text box
self.inText = JTextField()
self.inText.setFocusTraversalKeysEnabled(False)
self.inText.setFont(font)
self.inText.setBackground(Color(0, 20, 0))
self.inText.setForeground(Color.WHITE)
self.inText.getCaret().setVisible(True)
self.inText.getCaret().setBlinkRate(500)
self.inText.setCaretColor(Color(200,255,200))
class InFocusAdapter(FocusAdapter):
def focusLost(adap, e):
self.inText.setVisible(True)
self.inText.addFocusListener(InFocusAdapter())
self.nestedInputPanel = Panel("Insets 0 0 0 0")
#create the directory text box
self.directoryText = JTextField()
self.directoryText.setEditable(False)
self.directoryText.setFont(font)
self.directoryText.setBackground(Color(0, 20, 0))
self.directoryText.setForeground(Color.WHITE)
#set up the console
sys.stdout = FakeOut(self.outText)
self.console = BashED_Console(stdout=sys.stdout)
self.directoryText.setText(self.console.get_prompt())
self.revalidate();
dirTex = self.directoryText;
#create the listener that fires when the 'return' key is pressed
class InputTextActionListener(ActionListener):
def __init__(self,parent,inp,out,console):
self.parent = parent
self.inp = inp
self.out = out
self.console = console
def actionPerformed(self, e):
#print self.getCommandText()
# print(self.console.get_prompt())
# self.console.onecmd(self.inp.getText())
# self.parent.write_out("\n" + self.inp.getText())
# dirTex.setText(self.console.get_prompt())
# self.inp.setText("")
self.parent.write_out(self.console.get_prompt() + self.inp.getText() + '\n')
if 'clear' in self.inp.getText().split(' ')[0]:
self.out.setText("") #clear the screen
else:
self.console.onecmd(self.inp.getText())
dirTex.setText(self.console.get_prompt())
self.inp.setText("")
#create the listener that fires whenever a user hits a key
class InputKeyActionListener(KeyAdapter):
def __init__(self,parent,inp,out,console):
self.parent = parent
self.inp = inp
self.out = out
self.console = console
def keyReleased(self, k):
inp = self.inp.getText()
if k.getKeyCode() == 9: #tab character
autos = self.console.tabcomplete(self.inp.getText())
if len(autos) == 1:
self.inp.setText(autos[0])
else:
i = 0
for option in autos:
self.parent.write_out(option)
if i % 3 == 0:
print('\n')
else:
print('\t')
hist = None
if k.getKeyCode() == 38:
hist = self.console.next_hist()
if k.getKeyCode() == 40:
hist = self.console.last_hist()
if hist:
self.inp.setText(hist.rstrip('\n'))#prevent from firing
self.inText.addActionListener(InputTextActionListener(self,self.inText,self.outText,self.console))
self.inText.addKeyListener(InputKeyActionListener(self,self.inText,self.outText,self.console))
def addUI(self):
self.add(self.outTextScroller, "cell 0 0, push, grow")
self.add(self.nestedInputPanel, "cell 0 1, pushx, growx")
self.nestedInputPanel.add(self.directoryText, "cell 0 0")
self.nestedInputPanel.add(self.inText, "cell 1 0, spanx, pushx, growx")
inputPanel.add(JLabel("Project Name"))
inputPanel.add(projectNameTf)
imageNameTf = JTextField(job.imageName)
inputPanel.add(JLabel("Image Name"))
inputPanel.add(imageNameTf)
scaleLevelsTf = JTextField()
inputPanel.add(JLabel("Scale levels (empty=automatic)"))
inputPanel.add(scaleLevelsTf)
resolutionTf = JTextField()
inputPanel.add(JLabel("Resolution"))
inputPanel.add(resolutionTf)
resolutionTf.setText("%s, %s, %s" % job.resolution)
defaultMinTf = JTextField()
inputPanel.add(JLabel("Default display range min"))
inputPanel.add(defaultMinTf)
defaultMinTf.setText(str(job.displayMin))
defaultMaxTf = JTextField()
inputPanel.add(JLabel("Default display range max"))
inputPanel.add(defaultMaxTf)
defaultMaxTf.setText(str(job.displayMax))
inputPanel.add(JLabel("Output Directory"))
outputDirPanel = JPanel()
outputDirPanel.setLayout(BorderLayout())
outputDirTf = JTextField(job.outputDir)
class PreferencesFrame(JFrame, ActionListener, WindowListener, ItemListener, HyperlinkListener):
"""Dialog with preferences
"""
def __init__(self, parent, title, app):
from javax.swing import JCheckBox, JRadioButton, ButtonGroup
self.app = app
border = BorderFactory.createEmptyBorder(5, 7, 5, 7)
self.getContentPane().setBorder(border)
self.getContentPane().setLayout(BorderLayout(0, 5))
self.tabbedPane = JTabbedPane()
#1 Tab: general
panel1 = JPanel()
panel1.setBorder(BorderFactory.createEmptyBorder(7, 7, 7, 7))
panel1.setLayout(BoxLayout(panel1, BoxLayout.PAGE_AXIS))
#Checkbutton to enable/disable update check when script starts
self.updateCBtn = JCheckBox(self.app.strings.getString("updateCBtn"))
self.updateCBtn.setToolTipText(self.app.strings.getString("updateCBtn_tooltip"))
#Download tools
downloadBtn = JButton(self.app.strings.getString("updatesBtn"),
ImageProvider.get("dialogs", "refresh"),
actionPerformed=self.on_downloadBtn_clicked)
downloadBtn.setToolTipText(self.app.strings.getString("updatesBtn_tooltip"))
#Checkbuttons for enabling/disabling tools
toolsPanel = JPanel(BorderLayout(0, 5))
title = self.app.strings.getString("enable_disable_tools")
toolsPanel.setBorder(BorderFactory.createTitledBorder(title))
infoLbl = JLabel(self.app.strings.getString("JOSM_restart_warning"))
infoLbl.setFont(infoLbl.getFont().deriveFont(Font.ITALIC))
toolsPanel.add(infoLbl, BorderLayout.PAGE_START)
toolsStatusPane = JPanel(GridLayout(len(self.app.realTools), 0))
self.toolsCBtns = []
for tool in self.app.realTools:
toolCBtn = JCheckBox()
toolCBtn.addItemListener(self)
toolLbl = JLabel(tool.title, tool.bigIcon, JLabel.LEFT)
self.toolsCBtns.append(toolCBtn)
toolPane = JPanel()
toolPane.setLayout(BoxLayout(toolPane, BoxLayout.X_AXIS))
toolPane.add(toolCBtn)
toolPane.add(toolLbl)
toolsStatusPane.add(toolPane)
toolsPanel.add(toolsStatusPane, BorderLayout.CENTER)
#Radiobuttons for enabling/disabling layers when a new one
#is added
layersPanel = JPanel(GridLayout(0, 1))
title = self.app.strings.getString("errors_layers_manager")
layersPanel.setBorder(BorderFactory.createTitledBorder(title))
errorLayersLbl = JLabel(self.app.strings.getString("errors_layers_info"))
errorLayersLbl.setFont(errorLayersLbl.getFont().deriveFont(Font.ITALIC))
layersPanel.add(errorLayersLbl)
self.layersRBtns = {}
group = ButtonGroup()
for mode in self.app.layersModes:
layerRBtn = JRadioButton(self.app.strings.getString("%s" % mode))
group.add(layerRBtn)
layersPanel.add(layerRBtn)
self.layersRBtns[mode] = layerRBtn
#Max number of errors text field
self.maxErrorsNumberTextField = JTextField()
self.maxErrorsNumberTextField.setToolTipText(self.app.strings.getString("maxErrorsNumberTextField_tooltip"))
self.maxErrorsNumberTFieldDefaultBorder = self.maxErrorsNumberTextField.getBorder()
self.maxErrorsNumberTextField.getDocument().addDocumentListener(ErrNumTextListener(self))
#layout
self.updateCBtn.setAlignmentX(Component.LEFT_ALIGNMENT)
panel1.add(self.updateCBtn)
panel1.add(Box.createRigidArea(Dimension(0, 15)))
downloadBtn.setAlignmentX(Component.LEFT_ALIGNMENT)
panel1.add(downloadBtn)
panel1.add(Box.createRigidArea(Dimension(0, 15)))
toolsPanel.setAlignmentX(Component.LEFT_ALIGNMENT)
panel1.add(toolsPanel)
panel1.add(Box.createRigidArea(Dimension(0, 15)))
layersPanel.setAlignmentX(Component.LEFT_ALIGNMENT)
panel1.add(layersPanel)
panel1.add(Box.createRigidArea(Dimension(0, 15)))
maxErrP = JPanel(BorderLayout(5, 0))
maxErrP.add(JLabel(self.app.strings.getString("max_errors_number")), BorderLayout.LINE_START)
maxErrP.add(self.maxErrorsNumberTextField, BorderLayout.CENTER)
p = JPanel(BorderLayout())
p.add(maxErrP, BorderLayout.PAGE_START)
p.setAlignmentX(Component.LEFT_ALIGNMENT)
panel1.add(p)
self.tabbedPane.addTab(self.app.strings.getString("tab_1_title"),
None,
panel1,
None)
#2 Tab: favourite zones
panel2 = JPanel(BorderLayout(5, 15))
panel2.setBorder(BorderFactory.createEmptyBorder(7, 7, 7, 7))
#status
topPanel = JPanel()
topPanel.setLayout(BoxLayout(topPanel, BoxLayout.Y_AXIS))
infoPanel = HtmlPanel(self.app.strings.getString("fav_zones_info"))
infoPanel.getEditorPane().addHyperlinkListener(self)
infoPanel.setAlignmentX(Component.LEFT_ALIGNMENT)
self.favZoneStatusCBtn = JCheckBox(self.app.strings.getString("activate_fav_area"),
actionListener=self)
self.favZoneStatusCBtn.setToolTipText(self.app.strings.getString("activate_fav_area_tooltip"))
self.favZoneStatusCBtn.setAlignmentX(Component.LEFT_ALIGNMENT)
topPanel.add(infoPanel)
topPanel.add(Box.createRigidArea(Dimension(0, 10)))
topPanel.add(self.favZoneStatusCBtn)
#table
self.zonesTable = JTable()
tableSelectionModel = self.zonesTable.getSelectionModel()
tableSelectionModel.addListSelectionListener(ZonesTableListener(self))
columns = ["",
self.app.strings.getString("Type"),
self.app.strings.getString("Name")]
tableModel = ZonesTableModel([], columns)
self.zonesTable.setModel(tableModel)
self.scrollPane = JScrollPane(self.zonesTable)
#map
self.zonesMap = JMapViewer()
self.zonesMap.setZoomContolsVisible(False)
self.zonesMap.setMinimumSize(Dimension(100, 200))
#buttons
self.removeBtn = JButton(self.app.strings.getString("Remove"),
ImageProvider.get("dialogs", "delete"),
actionPerformed=self.on_removeBtn_clicked)
self.removeBtn.setToolTipText(self.app.strings.getString("remove_tooltip"))
newBtn = JButton(self.app.strings.getString("New"),
ImageProvider.get("dialogs", "add"),
actionPerformed=self.on_newBtn_clicked)
newBtn.setToolTipText(self.app.strings.getString("new_tooltip"))
#layout
panel2.add(topPanel, BorderLayout.PAGE_START)
panel2.add(self.scrollPane, BorderLayout.LINE_START)
panel2.add(self.zonesMap, BorderLayout.CENTER)
self.buttonsPanel = JPanel()
self.buttonsPanel.add(self.removeBtn)
self.buttonsPanel.add(newBtn)
panel2.add(self.buttonsPanel, BorderLayout.PAGE_END)
self.tabbedPane.addTab(self.app.strings.getString("tab_2_title"),
None,
panel2,
None)
#3 Tab Tools options
panel3 = JPanel()
panel3.setLayout(BoxLayout(panel3, BoxLayout.Y_AXIS))
panel3.setBorder(BorderFactory.createEmptyBorder(7, 7, 7, 7))
for tool in self.app.realTools:
if hasattr(tool, 'prefs'):
p = JPanel(FlowLayout(FlowLayout.LEFT))
p.setBorder(BorderFactory.createTitledBorder(tool.title))
p.add(tool.prefsGui)
panel3.add(p)
self.tabbedPane.addTab(self.app.strings.getString("tab_3_title"),
None,
panel3,
None)
self.add(self.tabbedPane, BorderLayout.CENTER)
exitPanel = JPanel()
saveBtn = JButton(self.app.strings.getString("OK"),
ImageProvider.get("ok"),
actionPerformed=self.on_saveBtn_clicked)
cancelBtn = JButton(self.app.strings.getString("cancel"),
ImageProvider.get("cancel"),
actionPerformed=self.on_cancelBtn_clicked)
saveBtn.setToolTipText(self.app.strings.getString("save_preferences"))
saveBtn.setAlignmentX(0.5)
exitPanel.add(saveBtn)
exitPanel.add(cancelBtn)
self.add(exitPanel, BorderLayout.PAGE_END)
self.addWindowListener(self)
self.pack()
def windowClosing(self, windowEvent):
self.on_cancelBtn_clicked()
def hyperlinkUpdate(self, e):
if e.getEventType() == HyperlinkEvent.EventType.ACTIVATED:
OpenBrowser.displayUrl(e.getURL().toString())
def itemStateChanged(self, e):
"""A ttol has been activated/deactivated.
Check if at least one tool is on.
"""
if all(not button.isSelected() for button in self.toolsCBtns):
JOptionPane.showMessageDialog(
Main.parent,
self.app.strings.getString("tools_disabled_warning"),
self.app.strings.getString("tools_disabled_warning_title"),
JOptionPane.WARNING_MESSAGE)
source = e.getItemSelectable()
source.setSelected(True)
def actionPerformed(self, e=None):
"""Enable/disable favourite zones panel
"""
for container in (self.scrollPane, self.buttonsPanel):
self.enableComponents(container, self.favZoneStatusCBtn.isSelected())
if self.favZoneStatusCBtn.isSelected():
self.check_removeBtn_status()
def enableComponents(self, container, enable):
components = container.getComponents()
for component in components:
component.setEnabled(enable)
if isinstance(component, Container):
self.enableComponents(component, enable)
def on_downloadBtn_clicked(self, e):
update_checker.Updater(self.app, "manual")
def clean_map(self):
"""Remove all rectangles and polygons from the map
"""
self.zonesMap.removeAllMapRectangles()
self.zonesMap.removeAllMapPolygons()
def update_gui_from_preferences(self):
"""Update gui status of preferences frame from config file
"""
#print "\n- updating Preferences gui"
onOff = {"on": True, "off": False}
#1 Tab
#check for update
self.updateCBtn.setSelected(onOff[self.app.checkUpdate])
#tools status, enabled or not
for toolIndex, tool in enumerate(self.app.realTools):
if "tool.%s" % tool.name in self.app.properties.keys():
configstatus = self.app.properties.getProperty("tool.%s" % tool.name)
else:
configstatus = "on" # new tool
self.toolsCBtns[toolIndex].setSelected(onOff[configstatus])
#layers preferences
for mode, button in self.layersRBtns.iteritems():
button.setSelected(mode == self.app.layersMode)
#max errors number
self.maxErrorsNumberTextField.setText(str(self.app.maxErrorsNumber))
#stats panel
self.app.dlg.update_favourite_zone_indicator()
#2 Tab
#favourite area
self.update_favourite_area_gui_from_preferences()
self.app.dlg.update_statsPanel_status()
#3 Tab
#tools preferences
for tool in self.app.allTools:
if hasattr(tool, 'prefs') and tool.prefsGui is not None:
tool.prefsGui.update_gui(tool.prefs)
def update_favourite_area_gui_from_preferences(self):
#status
self.favZoneStatusCBtn.setSelected(self.app.favouriteZoneStatus)
#table
#store zones to a temporary list, used to store changes
#and save them when preferences dialog is closed
self.app.tempZones = list(self.app.zones)
self.zonesTable.getModel().setNumRows(0)
for zone in self.app.tempZones:
self.zonesTable.getModel().addRow([zone.country,
zone.icon,
zone.name])
if self.app.favZone is not None:
selectedRow = self.app.tempZones.index(self.app.favZone)
self.zonesTable.setRowSelectionInterval(selectedRow, selectedRow)
self.zonesTable.getColumnModel().getColumn(0).setMaxWidth(30)
self.zonesTable.getColumnModel().getColumn(1).setMaxWidth(50)
#enable or disable favourite zone buttons
self.actionPerformed()
### fav area editing buttons ###########################################
def on_removeBtn_clicked(self, e):
rowsNum = self.zonesTable.getSelectedRows()
rowsNum.reverse()
for rowNum in rowsNum:
del self.app.tempZones[rowNum]
self.zonesTable.getModel().removeRow(rowNum)
if len(self.app.tempZones) != 0:
if rowNum == 0:
self.zonesTable.setRowSelectionInterval(0, 0)
else:
self.zonesTable.setRowSelectionInterval(rowNum - 1, rowNum - 1)
self.check_removeBtn_status()
def check_removeBtn_status(self):
if self.app.tempZones != [] and len(self.zonesTable.getSelectedRows()) != 0:
self.removeBtn.setEnabled(True)
else:
self.removeBtn.setEnabled(False)
self.clean_map()
def on_newBtn_clicked(self, e):
try:
self.newZoneDialog
except AttributeError:
self.newZoneDialog = NewZoneDialog(self.app)
bbox = self.app.get_frame_bounds()
self.app.newZone = Zone(self.app,
self.app.strings.getString("New_zone"),
"rectangle",
",".join(["%0.4f" % x for x in bbox]),
"")
self.newZoneDialog.update_gui_from_preferences()
self.newZoneDialog.show()
### Exit from preferences ##############################################
def on_cancelBtn_clicked(self, event=None):
if hasattr(self, "newZoneDialog") and self.newZoneDialog.isVisible():
self.newZoneDialog.close_dialog()
self.dispose()
def on_saveBtn_clicked(self, event):
"""Read preferences from gui and save them to config.properties
file
"""
#print "\n- saving preferences to config file"
onOff = {True: "on", False: "off"}
#1 Tab
#check for update
self.app.properties.setProperty("check_for_update",
onOff[self.updateCBtn.isSelected()])
#tools status
for toolIndex, tool in enumerate(self.app.realTools):
prop = "tool.%s" % tool.name
toolCBtn = self.toolsCBtns[toolIndex]
self.app.properties.setProperty(prop,
onOff[toolCBtn.isSelected()])
#layers preferences
for mode, button in self.layersRBtns.iteritems():
if button.isSelected():
self.app.properties.setProperty("layers_mode", mode)
break
#max errors number
try:
num = Integer.parseInt(self.maxErrorsNumberTextField.getText())
except NumberFormatException:
num = ""
self.app.properties.setProperty("max_errors_number", str(num))
#2 Tab
#Favourite zones
changes = {"new": [z for z in self.app.tempZones if not z in self.app.zones],
"deleted": [z for z in self.app.zones if not z in self.app.tempZones]}
#delete files of removed favourite zones
for zone in changes["deleted"]:
f = File(File.separator.join([self.app.SCRIPTDIR,
"configuration",
"favourite_zones",
"%s.txt" % zone.name]))
f.delete()
#create files for new favourite zones
for zone in changes["new"]:
print "\nsave new zone", zone.name
fileName = File.separator.join([self.app.SCRIPTDIR,
"configuration",
"favourite_zones",
"%s.txt" % zone.name])
f = open(fileName, "w")
zoneData = zone.geomString
if zone.country != "":
zoneData += "|" + zone.country
f.write(zoneData.encode("utf-8"))
f.close()
self.app.zones = self.app.tempZones
if len(self.app.zones) == 0:
self.app.favZone = None
self.app.properties.setProperty("favourite_area.name",
"")
self.favZoneStatusCBtn.setSelected(False)
else:
if len(self.zonesTable.getSelectedRows()) == 0:
self.app.favZone = self.app.zones[0]
else:
self.app.favZone = self.app.zones[self.zonesTable.getSelectedRows()[0]]
self.app.properties.setProperty("favourite_area.name",
self.app.favZone.name)
favZoneStatus = self.favZoneStatusCBtn.isSelected()
self.app.properties.setProperty("favourite_area.status", onOff[favZoneStatus])
self.app.favouriteZoneStatus = favZoneStatus
#stats panel
self.app.dlg.update_favourite_zone_indicator()
self.app.dlg.update_statsPanel_status()
#3 Tab
#tools preferences
for tool in self.app.allTools:
if hasattr(tool, 'prefs') and tool.prefsGui is not None:
for pref, value in tool.prefsGui.read_gui().iteritems():
prefKey = "tool.%s.%s" % (tool.name, pref)
self.app.properties.setProperty(prefKey, value)
self.app.save_config()
self.dispose()
class ChatApp(JFrame):
## Constructor function, initiate the base classes and call the GUI
def __init__(self):
'''Calls the base class and main UI
'''
# Call to the super class, initiates associated base classes
super(ChatApp, self).__init__()
# Call the Initial UI
self.initUI()
## Build the GUI for login, uses GroupLayout Manager for component positioning
def initUI(self):
'''Initial UI and Widget creation takes place here!
'''
self.setContentPane = JPanel()
#self.setDefaultLookAndFeelDecorated(True)
# Borders
foreground_colour = Color(30,57,68)
background_colour = Color(247,246,242)
window_background = Color(145,190,210)
self.border = BorderFactory.createLoweredBevelBorder()
self.border2 = BorderFactory.createLineBorder(foreground_colour, 1, True)
# Fonts
self.entry_font= Font("Ubuntu Light", Font.BOLD, 20)
self.label_font= Font("Ubuntu Light", Font.BOLD, 17)
self.btn_font=Font("Ubuntu Light", Font.BOLD, 15)
# Layout start
layout=GroupLayout(self.getContentPane())
self.getContentPane().setLayout(layout)
layout.setAutoCreateGaps(True)
layout.setAutoCreateContainerGaps(True)
self.setPreferredSize(Dimension(300, 150))
# Create the labels
user_label= JLabel(" Username : "******" Server : ", JLabel.LEFT, font=self.label_font)
# Colours
user_label.setForeground(foreground_colour)
server_label.setForeground(foreground_colour)
# Create the text entries
self.username=JTextField(actionPerformed=self.continueEvent, border=self.border2, font = self.entry_font)
self.server=JTextField(actionPerformed=self.continueEvent, border=self.border2, font = self.entry_font)
# Colours
self.username.setBackground(background_colour)
self.server.setBackground(background_colour)
self.username.setForeground(foreground_colour)
self.server.setForeground(foreground_colour)
# Allow editable
self.username.setEditable(True)
self.server.setEditable(True)
# Create the buttons
quit_btn=JButton(" Quit! ", actionPerformed=self.closeEvent, border=self.border2, font=self.btn_font)
go_btn=JButton(" Go! ", actionPerformed=self.continueEvent, border=self.border2, font=self.btn_font)
# Colours
quit_btn.setBackground(background_colour)
go_btn.setBackground(background_colour)
quit_btn.setForeground(foreground_colour)
go_btn.setForeground(foreground_colour)
# Setting up the horizontal groups parameters
layout.setHorizontalGroup(layout.createSequentialGroup()
# Left side
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.TRAILING)
.addComponent(user_label)
.addComponent(server_label))
# Right side
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.CENTER)
.addComponent(self.username)
.addComponent(self.server)
.addGroup(layout.createSequentialGroup()
.addComponent(quit_btn)
.addComponent(go_btn)))
)
# Setting up Vertical Groups
layout.setVerticalGroup(layout.createSequentialGroup()
# Top group
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.CENTER)
.addComponent(user_label)
.addComponent(self.username))
# Middle group
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.CENTER)
.addComponent(server_label)
.addComponent(self.server))
# Bottom group
.addGroup(layout.createParallelGroup()
.addComponent(quit_btn)
.addComponent(go_btn))
)
# Finalise the GUI
layout.linkSize(SwingConstants.HORIZONTAL, [quit_btn,go_btn])
self.getContentPane().setBackground(window_background)
self.pack()
self.setTitle('Chat Login')
self.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
self.setLocationRelativeTo(None)
self.setVisible(True)
## Event driven funtion to respond to quit button click
def closeEvent(self,event):
'''Function to close the login window
'''
print("Goodbye!")
exit()
## Event driven function to respond to send button click, grabs text and sends it down the wire
def continueEvent(self,event):
'''Function that retreives the login details for sending to the server
'''
# Grab the text that has been entered
user = self.username.getText()
Host = self.server.getText()
# Default port
Port=60001
connected=False
while not connected:
# Try make a connection except when there isn't one available, then quit program'
try:
tn=telnetlib.Telnet(Host, Port)
connected=True
continue
except:
JOptionPane.showMessageDialog(self,'Connection Error, No Server Available!')
self.username.setText('')
self.server.setText('')
self.username.requestFocusInWindow()
return
# Listen for a response
response = tn.read_until('<<<')
print(response)
# Acknowledge with the username
tn.write(user+'\r\n')
# Receive validation of name, present dialog if not valid
valid_name = tn.read_until('<')
valid_name.strip()
v_name, delim = valid_name.split('<')
if v_name.strip() != 'OK':
JOptionPane.showMessageDialog(self,'Bad Username, please choose another')
self.username.setText('')
self.username.requestFocusInWindow()
return
# Set the login GUI to hidden
self.setVisible(False) ## <<<<<< I have no idea why this doesn't work but I suspect it's something to do with either inheritance or having 2 class instances
# Call the main program, pass the connection as a parameter
ChatClient(user,response , tn)
class BurpExtender(IBurpExtender, IScannerCheck, IScanIssue, ITab):
def registerExtenderCallbacks(self, callbacks):
self.callbacks = callbacks
self.helpers = callbacks.getHelpers()
callbacks.setExtensionName("Missing Scanner Checks")
self.out = callbacks.getStdout()
# define all checkboxes
self.cbPassiveChecks = self.defineCheckBox("Passive Scanner Checks")
self.cbDOMXSS = self.defineCheckBox("DOM XSS", False)
self.cbDOMXSSSources = self.defineCheckBox("Sources", False)
self.cbDOMXSSSinks = self.defineCheckBox("Sinks")
self.cbDOMXSSjQuerySinks = self.defineCheckBox("jQuery Sinks", False)
self.grpDOMXSSSettings = JPanel()
self.grpDOMXSSSettings.add(self.cbDOMXSSSources)
self.grpDOMXSSSettings.add(self.cbDOMXSSSinks)
self.grpDOMXSSSettings.add(self.cbDOMXSSjQuerySinks)
self.cbSTS = self.defineCheckBox("Strict Transport Security")
self.lblSTSMin = JLabel("Minimum acceptable max-age")
self.inSTSMin = JTextField(str(STSMinimum), 9, actionPerformed=self.setSTSMinimum) # TODO: actionPerformed only fires on enter key - focus lost would be better
self.inSTSMin.setToolTipText("Enter the minimum max-age value which is considered as acceptable. Press return to change setting!")
self.grpSTSSettings = JPanel()
self.grpSTSSettings.add(self.lblSTSMin)
self.grpSTSSettings.add(self.inSTSMin)
self.cbXCTO = self.defineCheckBox("Content Sniffing")
self.cbXXP = self.defineCheckBox("Client-side XSS Filter Configuration")
self.cbRedirToHTTPS = self.defineCheckBox("Redirection from HTTP to HTTPS")
self.btnSave = JButton("Set as default", actionPerformed=self.saveConfig)
self.btnRestore = JButton("Restore", actionPerformed=self.restoreConfig)
self.grpConfig = JPanel()
self.grpConfig.add(self.btnSave)
self.grpConfig.add(self.btnRestore)
self.restoreConfig()
# definition of config tab
self.tab = JPanel()
layout = GroupLayout(self.tab)
self.tab.setLayout(layout)
layout.setAutoCreateGaps(True)
layout.setAutoCreateContainerGaps(True)
layout.setHorizontalGroup(
layout.createSequentialGroup()
.addGroup(layout.createParallelGroup()
.addComponent(self.cbPassiveChecks)
)
.addGroup(layout.createParallelGroup()
.addComponent(self.cbDOMXSS)
.addComponent(self.cbSTS)
.addComponent(self.cbXCTO)
.addComponent(self.cbXXP)
.addComponent(self.cbRedirToHTTPS)
)
.addGroup(layout.createParallelGroup()
.addComponent(self.grpDOMXSSSettings, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE)
.addComponent(self.grpSTSSettings, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE)
.addComponent(self.grpConfig, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE)
)
)
layout.setVerticalGroup(
layout.createSequentialGroup()
.addGroup(layout.createParallelGroup()
.addComponent(self.cbPassiveChecks)
.addComponent(self.cbDOMXSS)
.addComponent(self.grpDOMXSSSettings, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE)
)
.addGroup(layout.createParallelGroup()
.addComponent(self.cbSTS)
.addComponent(self.grpSTSSettings, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE)
)
.addComponent(self.cbXCTO)
.addComponent(self.cbXXP)
.addComponent(self.cbRedirToHTTPS)
.addComponent(self.grpConfig, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE)
)
self.domXSSSourcesRE = re.compile("(location\s*[\[.])|([.\[]\s*[\"']?\s*(arguments|dialogArguments|innerHTML|write(ln)?|open(Dialog)?|showModalDialog|cookie|URL|documentURI|baseURI|referrer|name|opener|parent|top|content|self|frames)\W)|(localStorage|sessionStorage|Database)")
# NOTE: done some optimizations here, original RE caused too much noise
# - added leading dot in the first part - original recognized "<a href=..." etc.
# - removed "value" in first part
self.domXSSSinksRE = re.compile("(\.(src|href|data|location|code|action)\s*[\"'\]]*\s*\+?\s*=)|((replace|assign|navigate|getResponseHeader|open(Dialog)?|showModalDialog|eval|evaluate|execCommand|execScript|setTimeout|setInterval)\s*[\"'\]]*\s*\()")
self.domXSSjQuerySinksRE = re.compile("after\(|\.append\(|\.before\(|\.html\(|\.prepend\(|\.replaceWith\(|\.wrap\(|\.wrapAll\(|\$\(|\.globalEval\(|\.add\(|jQUery\(|\$\(|\.parseHTML\(")
self.headerSTSRE = re.compile("^Strict-Transport-Security:.*?max-age=\"?(\d+)\"?", re.I) # TODO: multiple max-age directives cause confusion!
self.headerXCTORE = re.compile("^X-Content-Type-Options:\s*nosniff\s*$", re.I)
self.headerXXP = re.compile("^X-XSS-Protection:\s*(\d)(?:\s*;\s*mode\s*=\s*\"?(block)\"?)?", re.I)
self.headerLocationHTTPS = re.compile("^(?:Content-)?Location:\s*(https://.*)$", re.I)
callbacks.registerScannerCheck(self)
callbacks.addSuiteTab(self)
def defineCheckBox(self, caption, selected=True, enabled=True):
checkBox = JCheckBox(caption)
checkBox.setSelected(selected)
checkBox.setEnabled(enabled)
return checkBox
def setSTSMinimum(self, e=None):
val = self.inSTSMin.text
if re.match("^\d+$", val):
STSMinimum = int(val)
else:
self.inSTSMin.setText(str(STSMinimum)) # TODO: doesn't works as desired
def saveConfig(self, e=None):
config = {
'passiveChecks': self.cbPassiveChecks.isSelected(),
'DOMXSS': self.cbDOMXSS.isSelected(),
'DOMXSSSources': self.cbDOMXSSSources.isSelected(),
'DOMXSSSinks': self.cbDOMXSSSinks.isSelected(),
'DOMXSSjQuerySinks': self.cbDOMXSSjQuerySinks.isSelected(),
'STS': self.cbSTS.isSelected(),
'STSMin': self.inSTSMin.text,
'XCTO': self.cbXCTO.isSelected(),
'XXP': self.cbXXP.isSelected(),
'RedirToHTTPS': self.cbRedirToHTTPS.isSelected(),
}
self.callbacks.saveExtensionSetting("config", pickle.dumps(config))
def restoreConfig(self, e=None):
storedConfig = self.callbacks.loadExtensionSetting("config")
if storedConfig != None:
try:
config = pickle.loads(storedConfig)
self.cbPassiveChecks.setSelected(config['passiveChecks'])
self.cbDOMXSS.setSelected(config['DOMXSS'])
self.cbDOMXSSSources.setSelected(config['DOMXSSSources'])
self.cbDOMXSSSinks.setSelected(config['DOMXSSSinks'])
self.cbDOMXSSjQuerySinks.setSelected(config['DOMXSSjQuerySinks'])
self.cbSTS.setSelected(config['STS'])
self.inSTSMin.text = config['STSMin']
self.cbXCTO.setSelected(config['XCTO'])
self.cbXXP.setSelected(config['XXP'])
self.cbRedirToHTTPS.setSelected(config['RedirToHTTPS'])
self.setSTSMinimum()
except:
print("Classical case of \"shouldn't happen\": something went wrong with config restore. Submit a bug or patch and keep your eyes open for Zombies. Something is really strange here.\nConfig contained: " + storedConfig)
### ITab ###
def getTabCaption(self):
return("Additional Scanner Checks")
def getUiComponent(self):
return self.tab
### IScannerCheck ###
def doPassiveScan(self, baseRequestResponse):
if not self.cbPassiveChecks.isSelected():
return None
scanIssues = list()
requestProtocol = baseRequestResponse.getHttpService().getProtocol()
analyzedResponse = self.helpers.analyzeResponse(baseRequestResponse.getResponse())
responseHeaders = analyzedResponse.getHeaders()
bodyOffset = analyzedResponse.getBodyOffset()
responseBody = baseRequestResponse.getResponse()[analyzedResponse.getBodyOffset():].tostring()
# Identify DOMXSS sources and sinks
domXSSSources = list()
domXSSSinks = list()
domXSSjQuerySinks = list()
if self.cbDOMXSS.isSelected():
if self.cbDOMXSSSources.isSelected():
domXSSSources = self.domXSSSourcesRE.finditer(responseBody)
if self.cbDOMXSSSinks.isSelected():
domXSSSinks = self.domXSSSinksRE.finditer(responseBody)
if self.cbDOMXSSjQuerySinks.isSelected():
domXSSjQuerySinks = self.domXSSjQuerySinksRE.finditer(responseBody)
domXSSSourcesPos = extractMatchPositions(domXSSSources, bodyOffset)
domXSSSinksPos = extractMatchPositions(domXSSSinks, bodyOffset)
domXSSjQuerySinksPos = extractMatchPositions(domXSSjQuerySinks, bodyOffset)
if len(domXSSSourcesPos) + len(domXSSSinksPos) + len(domXSSjQuerySinksPos) > 0: # One of the DOMXSS REs matched
scanIssues.append(DOMXSSScanIssue(
baseRequestResponse,
domXSSSourcesPos,
domXSSSinksPos,
domXSSjQuerySinksPos,
self.helpers,
self.callbacks
))
# Identify missing, wrong or multiple occurring HTTP headers
headersSTS = list()
headersXCTO = list()
headersXXP = list()
headersLocationHTTPS = list()
offset = 0
for header in responseHeaders:
if self.cbSTS.isSelected():
match = self.headerSTSRE.match(header)
if match:
headersSTS.append((match, offset))
if self.cbXCTO.isSelected():
match = self.headerXCTORE.match(header)
if match:
headersXCTO.append(match)
if self.cbXXP.isSelected():
match = self.headerXXP.match(header)
if match:
headersXXP.append((match, offset))
if self.cbRedirToHTTPS.isSelected() and requestProtocol == 'http':
match = self.headerLocationHTTPS.match(header)
if match:
headersLocationHTTPS.append((match, offset))
offset += len(header) + 2 # TODO: assumption that CRLF is always used. The world is ugly, make a real check.
if requestProtocol != "https":
pass # HSTS only valid in HTTPS responses.
elif self.cbSTS.isSelected():
if len(headersSTS) == 0: # No HSTS header
scanIssues.append(STSScanIssue(
baseRequestResponse,
STSScanIssue.caseNoHeader,
None,
self.helpers,
self.callbacks
))
elif len(headersSTS) == 1 and int(headersSTS[0][0].group(1)) < STSMinimum: # HSTS header present, but time frame too short
scanIssues.append(STSScanIssue(
baseRequestResponse,
STSScanIssue.caseTooLow,
(int(headersSTS[0][0].group(1)), headersSTS[0][1] + headersSTS[0][0].start(1), headersSTS[0][1] + headersSTS[0][0].end(1)),
self.helpers,
self.callbacks
))
elif len(headersSTS) > 1: # multiple HSTS headers
scanIssues.append(STSScanIssue(
baseRequestResponse,
STSScanIssue.caseMultipleHeaders,
headersSTS,
self.helpers,
self.callbacks
))
# Redirection from HTTP to HTTPS
if self.cbRedirToHTTPS.isSelected() and len(headersLocationHTTPS) > 0:
scanIssues.append(RedirectFromHTTP2HTTPSScanIssue(
baseRequestResponse,
headersLocationHTTPS,
self.helpers,
self.callbacks
))
if self.cbXXP.isSelected():
if len(headersXXP) == 0: # No XSS protection header
scanIssues.append(XXPScanIssue(
baseRequestResponse,
XXPScanIssue.caseNoHeader,
None,
self.helpers,
self.callbacks
))
elif len(headersXXP) == 1 and int(headersXXP[0][0].group(1)) == 1 and headersXXP[0][0].group(2) != "block": # Activated but not in block mode
scanIssues.append(XXPScanIssue(
baseRequestResponse,
XXPScanIssue.caseNoBlockMode,
headersXXP,
self.helpers,
self.callbacks
))
elif len(headersXXP) > 1: # Multiple XXP headers
scanIssues.append(XXPScanIssue(
baseRequestResponse,
XXPScanIssue.caseMultipleHeaders,
headersXXP,
self.helpers,
self.callbacks
))
# "X-XSS-Protection: 0" already catched by Burp
# X-Content-Type-Options missing
# NOTE: it is assumed that multiple "X-Content-Type-Options: nosniff" headers can't cause confusion at browser side because they all have the same meaning.
if self.cbXCTO.isSelected() and len(headersXCTO) == 0:
scanIssues.append(XCTOScanIssue(
baseRequestResponse,
self.helpers,
self.callbacks
))
return scanIssues
def consolidateDuplicateIssues(self, existingIssue, newIssue):
if existingIssue.getIssueName() == newIssue.getIssueName():
if newIssue.getIssueName() == issueNameDOMXSS: # DOMXSS issues are different if response content is different.
responseExisting = existingIssue.getHttpMessages()[0].getResponse()
analyzedResponseExisting = self.helpers.analyzeResponse(responseExisting)
bodyOffsetExisting = analyzedResponseExisting.getBodyOffset()
responseBodyExisting = responseExisting.getResponse()[analyzedResponseExisting.getBodyOffset():].tostring()
responseNew = newIssue.getHttpMessages()[0].getResponse()
analyzedResponseNew = self.helpers.analyzeResponse(responseNew)
bodyOffsetNew = analyzedResponseNew.getBodyOffset()
responseBodyNew = responseNew.getResponse()[analyzedResponseNew.getBodyOffset():].tostring()
if responseBodyExisting == responseBodyNew:
return -1
else:
return 0
elif newIssue.getIssueName() == issueNameRedirectFromHTTP2HTTPS: # Redirection issues are different if target URLs differ
if existingIssue.getIssueDetail() == newIssue.getIssueDetail():
return -1
else:
return 0
else: # In all other cases: keep existing issue
return -1
return 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)"
class MPConfig(TreeSelectionListener):
"""The MPConfig component initializes the KConfig library with the requested configuration,
and buildst the GUI, consisting of a "Load" and a "Save as" buttons, a search field, "show all"
checkbox, tree view and information text view."""
def __init__(self,
kconfig_file="Kconfig",
config_file=".config",
systemLogger=None):
"""[summary]
Parameters
----------
kconfig_file : string (default: "Kconfig")
The Kconfig configuration file
config_file : string (default: ".config")
The save file which will be used for loading and saving the settings
systemLogger (default: None)
A system logger object. If None then print statements are used for logging.
"""
global log
if systemLogger:
log = systemLogger
# Load Kconfig configuration files
self.kconfig = Kconfig(kconfig_file)
setKConfig(self.kconfig)
if os.path.isfile(config_file):
log.info(self.kconfig.load_config(config_file))
elif os.path.isfile(".config"):
log.info(self.kconfig.load_config(".config"))
self.tree = KConfigTree(self.kconfig)
self.tree.addTreeSelectionListener(self.treeSelectionChanged)
jTreeSP = JScrollPane(self.tree)
self.jta = JTextArea()
self.jta.setEditable(False)
jTextSP = JScrollPane(self.jta)
toolPanel = JPanel()
toolPanel.setLayout(BoxLayout(toolPanel, BoxLayout.X_AXIS))
toolPanel.setBorder(BorderFactory.createEmptyBorder(2, 0, 2, 0))
toolPanel.add(JLabel("Search: "))
jSearchPanel = JPanel()
jSearchPanel.setLayout(BoxLayout(jSearchPanel, BoxLayout.X_AXIS))
self.jSearchField = JTextField()
jSearchPanel.setBackground(self.jSearchField.getBackground())
jSearchPanel.setBorder(self.jSearchField.getBorder())
self.jSearchField.setBorder(None)
self.jSearchField.getDocument().addDocumentListener(
SearchListener(self.tree))
jSearchPanel.add(self.jSearchField)
clearSearchButton = JButton(u'\u00d7',
actionPerformed=self.clearSearch)
d = clearSearchButton.getPreferredSize()
clearSearchButton.setPreferredSize(Dimension(d.height, d.height))
clearSearchButton.setBackground(self.jSearchField.getBackground())
clearSearchButton.setBorder(None)
clearSearchButton.setOpaque(False)
clearSearchButton.setContentAreaFilled(False)
clearSearchButton.setFocusPainted(False)
jSearchPanel.add(clearSearchButton)
toolPanel.add(jSearchPanel)
self.showAllCheckBox = JCheckBox("Show all",
actionPerformed=self.OnShowAllCheck)
toolPanel.add(self.showAllCheckBox)
splitPane = JSplitPane(JSplitPane.VERTICAL_SPLIT, jTreeSP, jTextSP)
splitPane.setOneTouchExpandable(True)
splitPane.setDividerLocation(300)
treePanel = JPanel(BorderLayout())
treePanel.add(toolPanel, BorderLayout.NORTH)
treePanel.add(splitPane, BorderLayout.CENTER)
loadSavePanel = JPanel()
loadSavePanel.setLayout(BoxLayout(loadSavePanel, BoxLayout.X_AXIS))
loadSavePanel.add(
JButton("Load", actionPerformed=self.loadConfigDialog))
loadSavePanel.add(
JButton("Save as", actionPerformed=self.writeConfigDialog))
self.rootPanel = JPanel()
self.rootPanel.setLayout(BorderLayout())
self.rootPanel.add(loadSavePanel, BorderLayout.PAGE_START)
self.rootPanel.add(treePanel, BorderLayout.CENTER)
def clearSearch(self, event):
self.jSearchField.setText("")
def OnShowAllCheck(self, event):
self.tree.setShowAll(self.showAllCheckBox.isSelected())
self.tree.doSearch(self.jSearchField.getText()
) # Must repeat the search if one is active
def treeSelectionChanged(self, event):
"""When the user selects a new node in the tree, show info about the selected node
in the info text area below the tree."""
path = event.getNewLeadSelectionPath()
if path:
comp = path.getLastPathComponent()
if isinstance(comp, DefaultMutableTreeNode):
nodeData = comp.getUserObject()
if isinstance(nodeData, TreeNodeData):
self.jta.setText(getNodeInfoString(nodeData.knode))
self.jta.setCaretPosition(0)
def getPane(self):
"""Return the panel containing all the other components that is set up in __init__()."""
return self.rootPanel
def writeConfig(self, fileName):
"""Write the current configuration to the file specified."""
self.kconfig.write_config(fileName) # Save full configuration
#self.kconfig.write_min_config(fileName) # Save minimal configuration
def loadConfig(self, fileName):
"""Load configuration settings from the file specified."""
if os.path.isfile(fileName):
log.info(self.kconfig.load_config(fileName))
self.tree.createKconfShadowModel(self.kconfig)
self.tree.updateTree()
def writeConfigDialog(self, e):
"""Open a file dialog to save configuration"""
fileChooser = JFileChooser(os.getcwd())
retval = fileChooser.showSaveDialog(None)
if retval == JFileChooser.APPROVE_OPTION:
f = fileChooser.getSelectedFile()
self.writeConfig(f.getPath())
def loadConfigDialog(self, e):
"""Open a file dialog to select configuration to load"""
fileChooser = JFileChooser(os.getcwd())
retval = fileChooser.showOpenDialog(None)
if retval == JFileChooser.APPROVE_OPTION:
f = fileChooser.getSelectedFile()
log.info("Selected file: " + f.getPath())
self.loadConfig(f.getPath())
class DemultiplexGUI(Runnable):
global SampleSheet
def __init__(self):
self.f = JFrame("Demultiplex the data")
self.f.setSize(1250, 1000)
self.f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
#Progress Monitor
self.pm=JProgressBar(100,100)
#Lane Area
self.LaneAre=JPanel()
self.lane1=JCheckBox("Lane 1", True)
self.lane2=JCheckBox("Lane 2", True)
self.lane3=JCheckBox("Lane 3", True)
self.lane4=JCheckBox("Lane 4", True)
self.lane5=JCheckBox("Lane 5", True)
self.lane6=JCheckBox("Lane 6", True)
self.lane7=JCheckBox("Lane 7", True)
self.lane8=JCheckBox("Lane 8", True)
self.LaneAre.add(self.lane1)
self.LaneAre.add(self.lane2)
self.LaneAre.add(self.lane3)
self.LaneAre.add(self.lane4)
self.LaneAre.add(self.lane5)
self.LaneAre.add(self.lane6)
self.LaneAre.add(self.lane7)
self.LaneAre.add(self.lane8)
self.txtArea = JPanel(GridLayout(15,0))
#self.txtArea.setPreferredSize(Dimension(150, 150))
self.textAreaForSheet = JTextField(30)
self.textAreaInputForFolder = JTextField(30)
self.textAreaOutPutFolder= JTextField(30)
self.txtArea.add(self.textAreaForSheet)
self.txtArea.add(self.textAreaInputForFolder)
self.txtArea.add(self.textAreaOutPutFolder)
self.txtArea.add(self.LaneAre)
self.buttonArea = JPanel(GridLayout(15,0))
#self.buttonArea.setPreferredSize(Dimension(150, 150))
self.sampleSheetBtn = JButton("SampleSheet", actionPerformed=self.onClickSample)
self.runOutPutFolder = JButton("RUN Folder",actionPerformed=self.onClickRun)
self.DemultiplexOutPutFolder = JButton("Output Folder",actionPerformed=self.onClickOut)
self.buttonArea.add(self.sampleSheetBtn)
self.buttonArea.add(self.runOutPutFolder)
self.buttonArea.add(self.DemultiplexOutPutFolder)
self.CheckBox = JPanel(GridLayout(15,0))
#self.buttonArea.setPreferredSize(Dimension(150, 150))
self.Iter1 = JCheckBox("01_0M_NY", True,)
self.Iter2 = JCheckBox("02_0M_N", True,)
self.Iter3 = JCheckBox("03_1M_NY", True,)
self.Iter4 = JCheckBox("04_1M_N", True,)
self.CheckBox.add(self.Iter1)
self.CheckBox.add(self.Iter2)
self.CheckBox.add(self.Iter3)
self.CheckBox.add(self.Iter4)
self.ExecutePanel = JPanel()
self.console=JTextArea(20,100)
self.sp = JScrollPane(self.console);
self.RunBtn = JButton("Demultiplex",actionPerformed= self.performDemultiplex)
self.CanBtn = JButton("Cancel",actionPerformed= self.CancelJob)
self.ExecutePanel.add(self.RunBtn)
self.ExecutePanel.add(self.CanBtn)
self.ExecutePanel.add(self.sp, BorderLayout.CENTER)
self.f.add(self.txtArea, BorderLayout.CENTER)
self.f.add(self.buttonArea, BorderLayout.WEST)
self.f.add(self.CheckBox, BorderLayout.EAST)
self.f.add(self.ExecutePanel, BorderLayout.NORTH)
self.f.add(self.pm,BorderLayout.SOUTH)
def run(self):
self.f.setVisible(True)
def onClickRun(self,event=""):
self.DirName= FolderChooser(self.f)
self.textAreaInputForFolder.setText(str(self.DirName))
def onClickOut(self,event=""):
self.OutDirName= FolderChooser(self.f)
self.textAreaOutPutFolder.setText(str(self.OutDirName))
def onClickSample(self,event):
self.sampleSheet=FileChooser(self.f)
self.textAreaForSheet.setText(str(self.sampleSheet))
def performDemultiplex(self,event):
NumberOfIterations=[self.Iter1.selected,self.Iter2.selected,self.Iter3.selected,self.Iter4.selected]
LaneNumber=[self.lane1.selected,self.lane2.selected,self.lane3.selected,self.lane4.selected,self.lane5.selected,self.lane6.selected,self.lane7.selected,self.lane8.selected]
selectedLanes = [str(i+1) for i, x in enumerate(LaneNumber) if x==True]
lanes=','.join(selectedLanes)
print LaneNumber,selectedLanes,lanes, lanes
self.task = ET.Task(self,NumberOfIterations,str(self.sampleSheet),str(self.DirName),str(self.OutDirName), lanes)
self.task.execute()
def CancelJob(self,event):
self.task.cancel(True)
def output(self, value):
eingabe = value.getString()
if eingabe == "Lexikon":
# Falls "Lexikon" an den Clienten übergeben wird, wird die GUI geöffnet,
# in der man deutsche Wörter eingeben kann, die einem dann auf Englisch
# vorgelesen werden.
def change_text(event):
text = feld.getText()
x = suche(text)
self.send(x)
frame.visible = False
frame = JFrame(
'Woerterbuch',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
size=(380, 350),
)
frame.setLayout(None)
frame.visible = True
hintergrund = ImageIcon("Hintergrund.jpg")
hintergrundlabel = JLabel(hintergrund)
frame.setContentPane(hintergrundlabel)
uebersetzerlabel = JLabel()
uebersetzerlabel.setForeground(Color(025, 025, 112))
uebersetzerlabel.setText(
"<html><font size=+1>Welches Wort soll ich uebersetzen?</font></html>"
)
uebersetzerlabel.setBounds(10, 20, 500, 50)
frame.add(uebersetzerlabel)
feld = JTextField()
feld.setText("")
feld.setBounds(20, 80, 300, 25)
frame.add(feld)
button = JButton('Uebersetzen',
actionPerformed=change_text,
size=(10, 20))
button.setBounds(20, 110, 300, 30)
frame.add(button)
if eingabe == "neue Lektion":
# Falls dem Clienten "neue Lektion" übergeben wird, öffnet er er die
# GUI für das Verwalten der Lektionen
frame = JFrame('Lektion erstellen',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
size=(1000, 1000))
frame.setLayout(None)
def auflisten_in(ort):
font = Font("Verdana", Font.BOLD, 15)
liste_mit_Lektionen = []
with open(pfad, "r") as f:
for line in f:
liste_mit_Lektionen.append(line.strip())
liste_mit_Lektionen.sort()
text = ""
for lektion in liste_mit_Lektionen:
text += lektion
text += "\n"
ort.setText(text)
ort.setFont(font)
frame.setLayout(None)
uebersichtLabel = JLabel()
def uebersetzen(event):
frage = feld_frage.getText()
x = suche(frage)
feld_frage.setText(x)
liste = []
with open(pfad, "r") as lektionen:
for lektion in lektionen:
if "nachgeschlagen" in lektion:
liste.append(lektion)
if liste:
name = liste[-1]
words = []
sql = "SELECT deutsch, englisch, symbol FROM " + name
zeile = stmt.executeQuery(sql)
while zeile.next():
d = zeile.getString("deutsch")
e = zeile.getString("englisch")
symb = zeile.getString("symbol")
words.append((d, e, symb))
if len(words) < 50:
sql = "INSERT INTO " + name + " (deutsch, englisch, symbol) VALUES(?,?,?);"
pstmt = conn.prepareStatement(sql)
pstmt.setString(1, frage)
pstmt.setString(2, x)
pstmt.setString(3, "X")
pstmt.executeUpdate()
else:
namensteile = name.split("_")
nummer = int(namensteile[1].strip()) + 1
name = "nachgeschlagen_" + str(nummer)
test = ""
with open(pfad, "r") as f:
for line in f:
test += line
if not name in test:
with open(pfad, "a") as f:
f.write(name + "\n")
sql = "CREATE TABLE " + name + " (deutsch text, englisch text, symbol text);"
stmt.execute(sql)
sql = "INSERT INTO " + name + " (deutsch, englisch, symbol) VALUES(?,?,?);"
pstmt = conn.prepareStatement(sql)
pstmt.setString(1, frage)
pstmt.setString(2, x)
pstmt.setString(3, "X")
pstmt.executeUpdate()
else:
name = "nachgeschlagen_1"
test = ""
with open(pfad, "r") as f:
for line in f:
test += line
if not name in test:
with open(pfad, "a") as f:
f.write(name + "\n")
sql = "CREATE TABLE " + name + " (deutsch text, englisch text, symbol text);"
stmt.execute(sql)
sql = "INSERT INTO " + name + " (deutsch, englisch, symbol) VALUES(?,?,?);"
pstmt = conn.prepareStatement(sql)
pstmt.setString(1, frage)
pstmt.setString(2, x)
pstmt.setString(3, "X")
pstmt.executeUpdate()
auflisten_in(uebersicht)
def delete(event):
name = feld.getText()
print name
print self.geladen
if name == self.geladen:
count = 0
while tabelle.getValueAt(count, 0) != None:
tabelle.setValueAt(None, count, 0)
tabelle.setValueAt(None, count, 1)
count += 1
stmt.execute("DROP TABLE " + name + ";")
lektionen = []
with open(pfad, "r") as f:
for line in f:
lektion = line.strip()
if not name == lektion:
lektionen.append(lektion)
with open(pfad, "w") as f:
for lektion in lektionen:
f.write(lektion + "\n")
auflisten_in(uebersicht)
def laden(event):
name = feld.getText()
self.geladen = name
sql = "SELECT deutsch, englisch FROM " + name
results = stmt.executeQuery(sql)
count = 0
while results.next():
d = results.getString("deutsch")
e = results.getString("englisch")
tabelle.setValueAt(d, count, 0)
tabelle.setValueAt(e, count, 1)
count += 1
while tabelle.getValueAt(count, 0) != None:
tabelle.setValueAt(None, count, 0)
tabelle.setValueAt(None, count, 1)
count += 1
def erstelle_Lektionstabelle(event):
reihen = []
for i in range(0, 50):
deutsch = tabelle.getValueAt(i, 0)
englisch = tabelle.getValueAt(i, 1)
if deutsch != None:
symbol = "X"
reihen.append([deutsch, englisch, symbol])
else:
break
z = 0
name = feld.getText()
sql = "CREATE TABLE " + name + " (deutsch text, englisch text, symbol text);"
try:
stmt.execute(sql)
except SQLError:
stmt.execute("DROP TABLE " + name + ";")
stmt.execute(sql)
for reihe in reihen:
print(reihe)
deutsch = reihe[0]
englisch = reihe[1]
symbol = reihe[2]
sql = "INSERT INTO " + name + " (deutsch, englisch, symbol) VALUES(?,?,?);"
pstmt = conn.prepareStatement(sql)
pstmt.setString(1, deutsch)
pstmt.setString(2, englisch)
pstmt.setString(3, symbol)
pstmt.executeUpdate()
test = ""
with open(pfad, "r") as f:
for line in f:
test += line
if not name in test:
with open(pfad, "a") as f:
f.write(name + "\n")
self.send(name)
frame.setVisible(False)
frame = JFrame('Vokabel Listen',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
size=(1000, 1000))
frame.setLayout(None)
label_enter = JLabel()
label_enter.setText(
"<html><font size=+0.5 color = 000000>Bitte vor dem Speichern<br>die Entertaste bedienen</font></html>"
)
label_enter.setBounds(20, 720, 250, 50)
uebersichtLabel = JLabel()
uebersichtLabel.setText(
"<html><font size=+1 color=#191970>Bereits vorhandene Lektionen:</font></html>"
)
uebersichtLabel.setBounds(450, 230, 250, 50)
uebersicht = JTextArea()
uebersicht.editable = False
uebersicht_scroll = JScrollPane(uebersicht)
uebersicht_scroll.viewport.view = uebersicht
uebersicht_scroll.setBounds(450, 300, 250, 380)
auflisten_in(uebersicht)
button = JButton('Lektion speichern/Lektion reseten',
actionPerformed=erstelle_Lektionstabelle,
size=(10, 20))
button.setBounds(20, 700, 300, 30)
button_laden = JButton('vorhandene Lektion laden',
actionPerformed=laden,
size=(10, 20))
button_laden.setBounds(20, 110, 210, 30)
button_delete = JButton("Lektion entfernen",
actionPerformed=delete)
button_delete.setBounds(20, 140, 210, 30)
hintergrund = ImageIcon("Hintergrund.jpg")
pnl = JPanel()
hintergrundlabel = JLabel(hintergrund)
frame.setContentPane(hintergrundlabel)
lektionsnamensLabel = JLabel()
lektionsnamensLabel.setForeground(Color(025, 025, 112))
lektionsnamensLabel.setText(
"<html><font size=+1>Hier bitte Namen der Lektion eingeben<br>(Nur ein Wort lang)</font></html>"
)
lektionsnamensLabel.setBounds(10, 20, 500, 50)
frame.add(lektionsnamensLabel)
feld = JTextField()
feld.setText("")
feld.setBounds(20, 80, 210, 25)
frame.add(feld)
column_names = [
"<html><font size=+1 color=#191970><b>Deutsch</b></font></html>",
"<html><font size=+1 color=#191970><b>Englisch</b></font></html>"
]
table_model = DefaultTableModel(column_names, 50)
tabelle = JTable(table_model)
lektionsnamensLabel.setForeground(Color(025, 025, 112))
scrollbar = JScrollPane(tabelle)
scrollbar.viewport.view = tabelle
scrollbar.setVerticalScrollBarPolicy(
scrollbar.VERTICAL_SCROLLBAR_ALWAYS)
scrollbar.setVisible(True)
tabelle.setVisible(True)
scrollbar.setBounds(20, 190, 300, 490)
feld_frage = JTextField()
feld_frage.setText("")
feld_frage.setBounds(450, 30, 300, 50)
uebersetzerlabel = JLabel()
uebersetzerlabel.setForeground(Color(025, 025, 112))
uebersetzerlabel.setText(
"<html><font size=+1>Hier kannst Du ein deutsches Wort eintragen,<br>dass ich fuer Dich nachschlage</font></html>"
)
uebersetzerlabel.setBounds(450, 80, 500, 50)
button_uebersetzen = JButton('Uebersetzen',
actionPerformed=uebersetzen,
size=(10, 20))
button_uebersetzen.setBounds(450, 130, 300, 30)
frame.add(button_uebersetzen)
frame.add(uebersetzerlabel)
frame.add(feld_frage)
frame.add(feld)
frame.add(scrollbar)
frame.add(button)
frame.add(button_laden)
frame.setVisible(True)
frame.add(uebersicht_scroll)
frame.add(uebersichtLabel)
frame.add(button_delete)
frame.add(label_enter)
elif eingabe == "alle Lektionen auflisten":
# Hier erstellt der Client eine dynamische Grammatik
# mit den vorhandenen Lektionen, die man sich abfragen lassen kann
# und gibt diese wieder an DialogOS zurück.
# Außerdem wird der Feedback Frame geöffnet.
def auflisten_in2(ort):
font = Font("Verdana", Font.BOLD, 15)
liste_mit_Lektionen = []
with open(pfad, "r") as f:
for line in f:
liste_mit_Lektionen.append(line.strip())
liste_mit_Lektionen.sort()
text = ""
for lektion in liste_mit_Lektionen:
text += lektion
text += "\n"
ort.setText(text)
ort.setFont(font)
frame_feedback.setVisible(True)
auflisten_in2(uebersicht2)
grammatik = ""
grammatik = "root $NamevonLektion;\n"
grammatik += "$NamevonLektion = "
with open(pfad, "r") as f:
z = 0
for line in f:
if z == 0:
if not "_" in line:
grammatik += line
else:
zeile = line.split("_")
grammatik += zeile[0] + " "
grammatik += zeile[1].strip()
else:
if not "_" in line:
grammatik += "|" + line
else:
zeile = line.split("_")
grammatik += "|" + zeile[0] + " "
grammatik += zeile[1].strip()
if line != "\n":
z += 1
grammatik += ";"
self.send(grammatik)
elif "sende" in eingabe:
# DialogOS sagt dem Clienten, welche Lektion der User abgefragt
# werden möchte. Der Client ließt dann die entsprechende Lektion
# aus der Datenbank aus und gibt eine Liste mit 2 Listen zurück.
# In der ersten Liste befinden sich die deutschen Bedeutungen, der
# noch nicht gewussten Wörter, in der 2. Liste die englsichen Bedeutungen.
# Falls alle Wörter bereits gekonnt wurden, wird stattdessen eine entsprechende
# Anmerkung an DialogOS geschickt und DialogOS informiert den User darüber.
z = 0
if "nachgeschlagen" in eingabe:
bestandteile = eingabe.split()
name = bestandteile[1] + "_" + bestandteile[2]
else:
name = eingabe.split()[1]
sql = "SELECT deutsch, englisch, symbol FROM " + name
vokabelliste = stmt.executeQuery(sql)
deutsch = []
englisch = []
symbol = []
while (vokabelliste.next()):
deutsch.append(vokabelliste.getString("deutsch"))
englisch.append(vokabelliste.getString("englisch"))
symbol.append(vokabelliste.getString("symbol"))
indices = range(0, len(deutsch))
random.shuffle(indices)
vokabeln = [[], []]
for index in indices:
d = deutsch[index]
e = englisch[index]
s = symbol[index]
if s == "X":
vokabeln[0].append(d)
vokabeln[1].append(e)
if vokabeln[0]:
self.send(vokabeln)
else:
self.send([
"Du kannst diese Lektion schon komplett. Wenn Du sie wieder abgefragt werden willst, resete sie bitte unter Wokabeln verwalten."
])
else:
# Dieser Teil des Codes wird während der Abfrage ausgeführt.
# Nach jeder neuen Vokabel wird dann in ein Feld im Feedback
# Frame die deutsche, die englische Vokabel und ein Symbol angezeigt,
# welches einen darüber informiert, ob man die Vokabel wusste, oder nicht.
# (O für gewusst und X für nicht gewusst)
nametext = eingabe.split(":")
name = nametext[0]
text = nametext[1]
feld_feedback.setText(text)
zeilen = text.split("\n")
symb = zeilen[-2].split("\t")[-1]
d = zeilen[-2].split("\t")[-3]
print d
sql = "UPDATE " + name + " SET symbol = ? WHERE deutsch = ?"
pstmt = conn.prepareStatement(sql)
pstmt.setString(1, symb)
pstmt.setString(2, d)
pstmt.executeUpdate()
class EditSettingsView(JDialog):
def __init__(self, controller, working_dir, servers, console_style,
edit_area_style, keystrokes, languages, projects):
self.logger = logging.getLogger("NammuController")
self.setAlwaysOnTop(True)
self.controller = controller
self.working_dir = working_dir
self.servers = servers
self.keystrokes = keystrokes
self.languages = languages
self.projects = projects
self.console_fontsize = console_style['fontsize']['user']
self.console_font_color = console_style['font_color']['user']
self.console_bg_color = console_style['background_color']['user']
self.edit_area_fontsize = edit_area_style['fontsize']['user']
self.pane = self.getContentPane()
# Grab the console color options from the console view
self.consoleView = self.controller.controller.consoleController.view
self.color_options = self.consoleView.colors.keys()
def build(self):
'''
Create all tab panels and put together to form the settings window.
'''
self.setLayout(BorderLayout())
self.add(self.build_tabbed_panel(), BorderLayout.CENTER)
self.add(self.build_buttons_panel(), BorderLayout.SOUTH)
def build_tabbed_panel(self):
'''
Build panel with tabs for each of the settings editable sections.
'''
tabbed_pane = JTabbedPane()
tab_titles = ["General", "Appearance", "Keystrokes", "Languages",
"Projects"]
for title in tab_titles:
panel = self.build_settings_panel(title.lower())
tabbed_pane.addTab(title, panel)
return tabbed_pane
def build_settings_panel(self, text):
'''
Call correspondent method to create panel for given tab text.
'''
panel = getattr(self, "build_{}_panel".format(text))()
return panel
def build_general_panel(self):
'''
Create the panel that'll go in the General tab. This should contain
options for choosing which server to use for validation as well as
default working dir.
'''
panel = JPanel(GridBagLayout())
constraints = self.add_constraints(GridBagConstraints(),
insets=Insets(10, 10, 10, 10))
self.build_working_dir_panel(constraints, panel)
self.build_servers_panel(constraints, panel)
return panel
def add_constraints(self, constraints, weightx=None, gridx=None,
gridy=None, fill=None, insets=None, gridwidth=None,
anchor=None):
'''
Wrapper around the various constraints we need to set.
'''
# Cant use pythonic truth value test as we need 0 to evaluate as true
if weightx is not None:
constraints.weightx = weightx
if gridx is not None:
constraints.gridx = gridx
if gridy is not None:
constraints.gridy = gridy
if fill is not None:
constraints.fill = fill
if insets is not None:
constraints.insets = insets
if gridwidth is not None:
constraints.gridwidth = gridwidth
if anchor is not None:
constraints.anchor = anchor
return constraints
def build_working_dir_panel(self, constraints, panel):
'''
Working directory row: label + field + button
This is for users to browse for their preferred default directory
when opening/creating a new file.
'''
working_dir_label = JLabel("Working directory:")
constraints = self.add_constraints(constraints, weightx=0.30,
gridx=0, gridy=0,
anchor=GridBagConstraints.EAST)
panel.add(working_dir_label, constraints)
self.wd_field = JTextField()
self.wd_field.setEditable(False)
# Can't find an elegant way to default to something that would be
# crossplatform, and I can't leave the default field empty.
if self.working_dir['default'] != "None":
self.wd_field.setText(self.working_dir['default'])
else:
self.wd_field.setText(os.getcwd())
constraints = self.add_constraints(constraints, weightx=0.60,
gridx=1, gridy=0,
fill=GridBagConstraints.HORIZONTAL,
insets=Insets(10, 10, 10, 5))
panel.add(self.wd_field, constraints)
constraints.fill = 0
button = JButton("Browse", actionPerformed=self.browse)
constraints = self.add_constraints(constraints, weightx=0.10,
gridx=2, gridy=0,
insets=Insets(10, 0, 10, 10))
panel.add(button, constraints)
def build_console_background_color_panel(self, constraints, panel):
'''
Server location row: label + dropdown
Contains a drop down with the servers to choose from.
'''
console_bg_label = JLabel("Console background color:")
constraints = self.add_constraints(constraints, weightx=0.30,
gridx=0, gridy=2)
panel.add(console_bg_label, constraints)
self.bg_color_combo = self.build_combobox(self.color_options,
self.console_bg_color)
constraints = self.add_constraints(constraints, weightx=0.70,
gridx=1, gridy=2, gridwidth=2,
fill=GridBagConstraints.HORIZONTAL)
panel.add(self.bg_color_combo, constraints)
def build_console_font_color_panel(self, constraints, panel):
'''
Server location row: label + dropdown
Contains a drop down with the servers to choose from.
'''
console_font_label = JLabel("Console font color:")
constraints = self.add_constraints(constraints, weightx=0.30,
gridx=0, gridy=3)
panel.add(console_font_label, constraints)
self.font_color_combo = self.build_combobox(self.color_options,
self.console_font_color)
constraints = self.add_constraints(constraints, weightx=0.70,
gridx=1, gridy=3, gridwidth=2,
fill=GridBagConstraints.HORIZONTAL)
panel.add(self.font_color_combo, constraints)
def build_servers_panel(self, constraints, panel):
'''
Server location row: label + dropdown
Contains a drop down with the servers to choose from.
'''
server_label = JLabel("ORACC server location:")
constraints = self.add_constraints(constraints, weightx=0.30,
gridx=0, gridy=1,
insets=Insets(10, 10, 80, 10))
panel.add(server_label, constraints)
self.combo = self.build_servers_combobox()
constraints = self.add_constraints(constraints, weightx=0.70,
gridx=1, gridy=1, gridwidth=2,
fill=GridBagConstraints.HORIZONTAL)
panel.add(self.combo, constraints)
def build_console_font_panel(self, constraints, panel):
'''
Font size on a textfield.
'''
fontzise_label = JLabel("Console font size:")
constraints = self.add_constraints(constraints, weightx=0.20,
gridx=0, gridy=0,
fill=GridBagConstraints.HORIZONTAL)
panel.add(fontzise_label, constraints)
self.fs_field = JTextField()
self.fs_field.setEditable(True)
if self.console_fontsize:
self.fs_field.setText("{}".format(self.console_fontsize))
else:
self.fs_field.setText(self.controller.config[
'console_style']['fontsize']['default'])
constraints = self.add_constraints(constraints, weightx=0.80,
gridx=1, gridy=0,
fill=GridBagConstraints.HORIZONTAL)
panel.add(self.fs_field, constraints)
def build_edit_area_font_panel(self, constraints, panel):
'''
Font size on a textfield.
'''
fontzise_label = JLabel("Edit area font size:")
constraints = self.add_constraints(constraints, weightx=0.20,
gridx=0, gridy=4)
panel.add(fontzise_label, constraints)
self.edit_area_fs_field = JTextField()
self.edit_area_fs_field.setEditable(True)
if self.edit_area_fontsize:
self.edit_area_fs_field.setText(
"{}".format(self.edit_area_fontsize))
else:
self.edit_area_fs_field.setText(self.controller.config[
'edit_area_style']['fontsize']['default'])
constraints = self.add_constraints(constraints, weightx=0.80,
gridx=1, gridy=4,
fill=GridBagConstraints.HORIZONTAL)
panel.add(self.edit_area_fs_field, constraints)
def build_combobox(self, choices, default):
'''
Generic method to construct a combobox. choices should be an iterable
of strings of the choices to be made and default should be a string
which is equal to one of the values within the iterable.
'''
combo = JComboBox()
for choice in choices:
combo.addItem(choice)
combo.setSelectedItem(default)
return combo
def build_servers_combobox(self):
combo = JComboBox()
# Go through list of servers and add to combo box.
for server in self.servers.keys():
if server != "default":
combo_item = "{}: {}:{}".format(server,
self.servers[server]['url'],
self.servers[server]['port'])
combo.addItem(combo_item)
# If this item is the default one, set it as selected
if server == self.servers['default']:
combo.setSelectedItem(combo_item)
return combo
def build_buttons_panel(self):
'''
Builds the buttons panel to save or cancel changes.
TODO: Reset button to reset to defaults?
'''
panel = JPanel(FlowLayout())
panel.add(JButton('Cancel', actionPerformed=self.cancel))
panel.add(JButton('Save', actionPerformed=self.save))
return panel
def build_keystrokes_panel(self):
'''
Create the panel that'll go in the Keystrokes tab. This should contain
options for choosing which keystrokes are to be assigned to which
actions.
'''
panel = JPanel()
label = JLabel("Coming soon...")
panel.add(label, BorderLayout.CENTER)
return panel
def build_languages_panel(self):
'''
Create the panel that'll go in the Languages tab. This should contain
options for choosing which is the list of languages that can be
included from the new ATF window and their abbrv.
'''
panel = JPanel()
label = JLabel("Coming soon...")
panel.add(label, BorderLayout.CENTER)
return panel
def build_projects_panel(self):
'''
Create the panel that'll go in the Projects tab. This should contain
the list of preferred projects and a means to select which is the
preferred default.
'''
panel = JPanel()
label = JLabel("Coming soon...")
panel.add(label, BorderLayout.CENTER)
return panel
def build_appearance_panel(self):
'''
Create the panel that'll go in the General tab. This should contain
options for choosing which server to use for validation as well as
default working dir.
'''
panel = JPanel(GridBagLayout())
constraints = self.add_constraints(GridBagConstraints(),
insets=Insets(10, 10, 10, 10))
self.build_console_font_panel(constraints, panel)
self.build_console_font_color_panel(constraints, panel)
self.build_console_background_color_panel(constraints, panel)
self.build_edit_area_font_panel(constraints, panel)
return panel
def display(self):
'''
Displays window.
'''
self.build()
self.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
self.setResizable(False)
self.setTitle("Edit settings")
self.pack()
self.setLocationRelativeTo(None)
self.visible = 1
def display_error(self, keyword):
'''
Display error message when keyword is not in settings file.
'''
pass
def cancel(self, event=None):
'''
Close window and don't save changes.
'''
self.dispose()
def validate_fontsize(self, input_size, target_key):
'''
Method to validate an input fontsize. The target key points to either
the console font sizes 'console_style' or the edit area font sizes
'edit_area_style'. If the value is invalid, return the previous user
fontsize that was stored.
The second return value is a bool indicating if the value has changed.
'''
# Extract plain english from key name for use in error message
target = target_key[:-6].replace('_', ' ')
# Use isnumeric() to test if a unicode string only has digits
if (input_size.isnumeric() and (8 <= int(input_size) <= 30)):
return input_size, True
else:
input_size = self.controller.config[target_key]['fontsize']['user']
self.logger.error("Invalid {} font size. Please enter a "
"number between 8 and 36.\n\n"
"Font size left at "
"previous value: {}".format(target, input_size))
return input_size, False
def validate_colors(self, bg_color, font_color):
'''
Validate console colors to ensure they do not match.
The second return value is a bool indicating if the value has changed.
'''
valid = True
if bg_color == font_color:
config = self.controller.config
self.logger.error("Console font colour cannot match background"
" colour. Resetting to default values.")
bg_color = config['console_style']['background_color']['default']
font_color = config['console_style']['font_color']['default']
valid = False
return bg_color, font_color, valid
def validate_working_dir(self, working_dir):
'''
Method to validate input working directories. If directory does not
exist or if a path to a file is provided instead of a path to a
directory the method returns None.
The second return value is a bool indicating if the value has changed.
'''
if os.path.isdir(working_dir):
return working_dir, True
else:
self.logger.error("{} is not a valid working directory."
" No working directory has been "
"saved".format(working_dir))
return None, False
def validate_all_inputs(self, working_dir, console_fontsize,
edit_area_fontsize, bg_color, font_color):
'''
Wrapper around the input validation methods. Returns a tuple containing
the validated inputs with the last value in the tuple a boolean set to
False if any of the values have been altered during the validation
and True if there have been no changes.
'''
# Collect the results of each validation. In future we might use this
# to provide more detailed error logging on bad user input
validation_results = []
# Validate the working directory input string
working_dir, v = self.validate_working_dir(working_dir)
validation_results.append(v)
# Validate the input fontsizes
con_size, v = self.validate_fontsize(console_fontsize, 'console_style')
validation_results.append(v)
edit_size, v = self.validate_fontsize(edit_area_fontsize,
'edit_area_style')
validation_results.append(v)
# Validate input console colors
bg_color, font_color, v = self.validate_colors(bg_color, font_color)
validation_results.append(v)
return (working_dir, int(con_size), font_color, bg_color,
int(edit_size), all(validation_results))
def save(self, event=None):
'''
Save changes made by user on local settings file.
'''
# Update only the working_dir and the server for now
# TODO: update keystrokes, projects list, etc.
working_dir = self.wd_field.getText()
# Read the fontsize from the textfield
console_fontsize = self.fs_field.getText()
edit_area_fontsize = self.edit_area_fs_field.getText()
# Get the user selected font and background colours
bg_color = self.bg_color_combo.getSelectedItem()
font_color = self.font_color_combo.getSelectedItem()
validated = self.validate_all_inputs(working_dir, console_fontsize,
edit_area_fontsize, bg_color,
font_color)
# The server format is "name: url:port". We only need "name"
server = self.combo.getSelectedItem().split(':')[0]
self.controller.update_config(validated[0], server,
validated[1], validated[2],
validated[3], int(validated[4]))
# If no values have been changed, print that settings have been
# updated without errors
if validated[5]:
self.logger.info("Settings have been successfully updated.")
# On saving settings, update the console and edit area properties
self.controller.refreshConsole()
self.controller.refreshEditArea()
# Close window
self.dispose()
# Refresh the syntax highlighting in a separate thread so it updates
# after everything else has been done.
runSwingLater(self.controller.controller.initHighlighting)
def browse(self, event=None):
'''
Open new dialog for the user to select a path as default working dir.
'''
default_path = self.wd_field.getText()
if not os.path.isdir(default_path):
default_path = os.getcwd()
fileChooser = JFileChooser(default_path)
fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
# Fixed showDialog bug using showOpenDialog instead. The former was
# duplicating the last folder name in the path due to a Java bug in
# OSX in the implementation of JFileChooser!
status = fileChooser.showOpenDialog(self)
if status == JFileChooser.APPROVE_OPTION:
self.wd_field.setText(fileChooser.getSelectedFile().toString())
class BurpExtender(IBurpExtender, IScannerCheck, IScanIssue, ITab):
def registerExtenderCallbacks(self, callbacks):
self.callbacks = callbacks
self.helpers = callbacks.getHelpers()
callbacks.setExtensionName("Missing Scanner Checks")
self.out = callbacks.getStdout()
# define all checkboxes
self.cbPassiveChecks = self.defineCheckBox("Passive Scanner Checks")
self.cbDOMXSS = self.defineCheckBox("DOM XSS", False)
self.cbDOMXSSSources = self.defineCheckBox("Sources", False)
self.cbDOMXSSSinks = self.defineCheckBox("Sinks")
self.cbDOMXSSjQuerySinks = self.defineCheckBox("jQuery Sinks", False)
self.grpDOMXSSSettings = JPanel()
self.grpDOMXSSSettings.add(self.cbDOMXSSSources)
self.grpDOMXSSSettings.add(self.cbDOMXSSSinks)
self.grpDOMXSSSettings.add(self.cbDOMXSSjQuerySinks)
self.cbSTS = self.defineCheckBox("Strict Transport Security")
self.lblSTSMin = JLabel("Minimum acceptable max-age")
self.inSTSMin = JTextField(
str(STSMinimum), 9, actionPerformed=self.setSTSMinimum
) # TODO: actionPerformed only fires on enter key - focus lost would be better
self.inSTSMin.setToolTipText(
"Enter the minimum max-age value which is considered as acceptable. Press return to change setting!"
)
self.grpSTSSettings = JPanel()
self.grpSTSSettings.add(self.lblSTSMin)
self.grpSTSSettings.add(self.inSTSMin)
self.cbXCTO = self.defineCheckBox("Content Sniffing")
self.cbXXP = self.defineCheckBox(
"Client-side XSS Filter Configuration")
self.cbRedirToHTTPS = self.defineCheckBox(
"Redirection from HTTP to HTTPS")
self.btnSave = JButton("Set as default",
actionPerformed=self.saveConfig)
self.btnRestore = JButton("Restore",
actionPerformed=self.restoreConfig)
self.grpConfig = JPanel()
self.grpConfig.add(self.btnSave)
self.grpConfig.add(self.btnRestore)
self.restoreConfig()
# definition of config tab
self.tab = JPanel()
layout = GroupLayout(self.tab)
self.tab.setLayout(layout)
layout.setAutoCreateGaps(True)
layout.setAutoCreateContainerGaps(True)
layout.setHorizontalGroup(layout.createSequentialGroup().addGroup(
layout.createParallelGroup().addComponent(self.cbPassiveChecks)
).addGroup(layout.createParallelGroup().addComponent(
self.cbDOMXSS).addComponent(self.cbSTS).addComponent(
self.cbXCTO).addComponent(self.cbXXP).addComponent(
self.cbRedirToHTTPS)).addGroup(
layout.createParallelGroup().addComponent(
self.grpDOMXSSSettings, GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE).addComponent(
self.grpSTSSettings,
GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE).addComponent(
self.grpConfig, GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE)))
layout.setVerticalGroup(layout.createSequentialGroup().addGroup(
layout.createParallelGroup().addComponent(
self.cbPassiveChecks).addComponent(self.cbDOMXSS).addComponent(
self.grpDOMXSSSettings, GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE)).addGroup(
layout.createParallelGroup().addComponent(
self.cbSTS).addComponent(
self.grpSTSSettings,
GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE)).addComponent(
self.cbXCTO).addComponent(
self.cbXXP).addComponent(
self.cbRedirToHTTPS).addComponent(
self.grpConfig,
GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE,
GroupLayout.PREFERRED_SIZE))
self.domXSSSourcesRE = re.compile(
"(location\s*[\[.])|([.\[]\s*[\"']?\s*(arguments|dialogArguments|innerHTML|write(ln)?|open(Dialog)?|showModalDialog|cookie|URL|documentURI|baseURI|referrer|name|opener|parent|top|content|self|frames)\W)|(localStorage|sessionStorage|Database)"
)
# NOTE: done some optimizations here, original RE caused too much noise
# - added leading dot in the first part - original recognized "<a href=..." etc.
# - removed "value" in first part
self.domXSSSinksRE = re.compile(
"(\.(src|href|data|location|code|action)\s*[\"'\]]*\s*\+?\s*=)|((replace|assign|navigate|getResponseHeader|open(Dialog)?|showModalDialog|eval|evaluate|execCommand|execScript|setTimeout|setInterval)\s*[\"'\]]*\s*\()"
)
self.domXSSjQuerySinksRE = re.compile(
"after\(|\.append\(|\.before\(|\.html\(|\.prepend\(|\.replaceWith\(|\.wrap\(|\.wrapAll\(|\$\(|\.globalEval\(|\.add\(|jQUery\(|\$\(|\.parseHTML\("
)
self.headerSTSRE = re.compile(
"^Strict-Transport-Security:.*?max-age=\"?(\d+)\"?",
re.I) # TODO: multiple max-age directives cause confusion!
self.headerXCTORE = re.compile(
"^X-Content-Type-Options:\s*nosniff\s*$", re.I)
self.headerXXP = re.compile(
"^X-XSS-Protection:\s*(\d)(?:\s*;\s*mode\s*=\s*\"?(block)\"?)?",
re.I)
self.headerLocationHTTPS = re.compile(
"^(?:Content-)?Location:\s*(https://.*)$", re.I)
callbacks.registerScannerCheck(self)
callbacks.addSuiteTab(self)
def defineCheckBox(self, caption, selected=True, enabled=True):
checkBox = JCheckBox(caption)
checkBox.setSelected(selected)
checkBox.setEnabled(enabled)
return checkBox
def setSTSMinimum(self, e=None):
val = self.inSTSMin.text
if re.match("^\d+$", val):
STSMinimum = int(val)
else:
self.inSTSMin.setText(
str(STSMinimum)) # TODO: doesn't works as desired
def saveConfig(self, e=None):
config = {
'passiveChecks': self.cbPassiveChecks.isSelected(),
'DOMXSS': self.cbDOMXSS.isSelected(),
'DOMXSSSources': self.cbDOMXSSSources.isSelected(),
'DOMXSSSinks': self.cbDOMXSSSinks.isSelected(),
'DOMXSSjQuerySinks': self.cbDOMXSSjQuerySinks.isSelected(),
'STS': self.cbSTS.isSelected(),
'STSMin': self.inSTSMin.text,
'XCTO': self.cbXCTO.isSelected(),
'XXP': self.cbXXP.isSelected(),
'RedirToHTTPS': self.cbRedirToHTTPS.isSelected(),
}
self.callbacks.saveExtensionSetting("config", pickle.dumps(config))
def restoreConfig(self, e=None):
storedConfig = self.callbacks.loadExtensionSetting("config")
if storedConfig != None:
try:
config = pickle.loads(storedConfig)
self.cbPassiveChecks.setSelected(config['passiveChecks'])
self.cbDOMXSS.setSelected(config['DOMXSS'])
self.cbDOMXSSSources.setSelected(config['DOMXSSSources'])
self.cbDOMXSSSinks.setSelected(config['DOMXSSSinks'])
self.cbDOMXSSjQuerySinks.setSelected(
config['DOMXSSjQuerySinks'])
self.cbSTS.setSelected(config['STS'])
self.inSTSMin.text = config['STSMin']
self.cbXCTO.setSelected(config['XCTO'])
self.cbXXP.setSelected(config['XXP'])
self.cbRedirToHTTPS.setSelected(config['RedirToHTTPS'])
self.setSTSMinimum()
except:
print(
"Classical case of \"shouldn't happen\": something went wrong with config restore. Submit a bug or patch and keep your eyes open for Zombies. Something is really strange here.\nConfig contained: "
+ storedConfig)
### ITab ###
def getTabCaption(self):
return ("Additional Scanner Checks")
def getUiComponent(self):
return self.tab
def doActiveScan(self, baseRequestResponse, insertionPoint):
pass
### IScannerCheck ###
def doPassiveScan(self, baseRequestResponse):
if not self.cbPassiveChecks.isSelected():
return None
scanIssues = list()
requestProtocol = baseRequestResponse.getHttpService().getProtocol()
analyzedResponse = self.helpers.analyzeResponse(
baseRequestResponse.getResponse())
responseHeaders = analyzedResponse.getHeaders()
bodyOffset = analyzedResponse.getBodyOffset()
responseBody = baseRequestResponse.getResponse(
)[analyzedResponse.getBodyOffset():].tostring()
# Identify DOMXSS sources and sinks
domXSSSources = list()
domXSSSinks = list()
domXSSjQuerySinks = list()
if self.cbDOMXSS.isSelected():
if self.cbDOMXSSSources.isSelected():
domXSSSources = self.domXSSSourcesRE.finditer(responseBody)
if self.cbDOMXSSSinks.isSelected():
domXSSSinks = self.domXSSSinksRE.finditer(responseBody)
if self.cbDOMXSSjQuerySinks.isSelected():
domXSSjQuerySinks = self.domXSSjQuerySinksRE.finditer(
responseBody)
domXSSSourcesPos = extractMatchPositions(domXSSSources, bodyOffset)
domXSSSinksPos = extractMatchPositions(domXSSSinks, bodyOffset)
domXSSjQuerySinksPos = extractMatchPositions(
domXSSjQuerySinks, bodyOffset)
if len(domXSSSourcesPos) + len(domXSSSinksPos) + len(
domXSSjQuerySinksPos) > 0: # One of the DOMXSS REs matched
scanIssues.append(
DOMXSSScanIssue(baseRequestResponse, domXSSSourcesPos,
domXSSSinksPos, domXSSjQuerySinksPos,
self.helpers, self.callbacks))
# Identify missing, wrong or multiple occurring HTTP headers
headersSTS = list()
headersXCTO = list()
headersXXP = list()
headersLocationHTTPS = list()
offset = 0
for header in responseHeaders:
if self.cbSTS.isSelected():
match = self.headerSTSRE.match(header)
if match:
headersSTS.append((match, offset))
if self.cbXCTO.isSelected():
match = self.headerXCTORE.match(header)
if match:
headersXCTO.append(match)
if self.cbXXP.isSelected():
match = self.headerXXP.match(header)
if match:
headersXXP.append((match, offset))
if self.cbRedirToHTTPS.isSelected() and requestProtocol == 'http':
match = self.headerLocationHTTPS.match(header)
if match:
headersLocationHTTPS.append((match, offset))
offset += len(
header
) + 2 # TODO: assumption that CRLF is always used. The world is ugly, make a real check.
if requestProtocol != "https":
pass # HSTS only valid in HTTPS responses.
elif self.cbSTS.isSelected():
if len(headersSTS) == 0: # No HSTS header
scanIssues.append(
STSScanIssue(baseRequestResponse,
STSScanIssue.caseNoHeader, None, self.helpers,
self.callbacks))
elif len(headersSTS) == 1 and int(
headersSTS[0][0].group(1)
) < STSMinimum: # HSTS header present, but time frame too short
scanIssues.append(
STSScanIssue(baseRequestResponse, STSScanIssue.caseTooLow,
(int(headersSTS[0][0].group(1)),
headersSTS[0][1] + headersSTS[0][0].start(1),
headersSTS[0][1] + headersSTS[0][0].end(1)),
self.helpers, self.callbacks))
elif len(headersSTS) > 1: # multiple HSTS headers
scanIssues.append(
STSScanIssue(baseRequestResponse,
STSScanIssue.caseMultipleHeaders, headersSTS,
self.helpers, self.callbacks))
# Redirection from HTTP to HTTPS
if self.cbRedirToHTTPS.isSelected() and len(headersLocationHTTPS) > 0:
scanIssues.append(
RedirectFromHTTP2HTTPSScanIssue(baseRequestResponse,
headersLocationHTTPS,
self.helpers, self.callbacks))
if self.cbXXP.isSelected():
if len(headersXXP) == 0: # No XSS protection header
scanIssues.append(
XXPScanIssue(baseRequestResponse,
XXPScanIssue.caseNoHeader, None, self.helpers,
self.callbacks))
elif len(headersXXP) == 1 and int(
headersXXP[0][0].group(1)) == 1 and headersXXP[0][0].group(
2) != "block": # Activated but not in block mode
scanIssues.append(
XXPScanIssue(baseRequestResponse,
XXPScanIssue.caseNoBlockMode, headersXXP,
self.helpers, self.callbacks))
elif len(headersXXP) > 1: # Multiple XXP headers
scanIssues.append(
XXPScanIssue(baseRequestResponse,
XXPScanIssue.caseMultipleHeaders, headersXXP,
self.helpers, self.callbacks))
# "X-XSS-Protection: 0" already catched by Burp
# X-Content-Type-Options missing
# NOTE: it is assumed that multiple "X-Content-Type-Options: nosniff" headers can't cause confusion at browser side because they all have the same meaning.
if self.cbXCTO.isSelected() and len(headersXCTO) == 0:
scanIssues.append(
XCTOScanIssue(baseRequestResponse, self.helpers,
self.callbacks))
return scanIssues
def consolidateDuplicateIssues(self, existingIssue, newIssue):
if existingIssue.getIssueName() == newIssue.getIssueName():
if newIssue.getIssueName(
) == issueNameDOMXSS: # DOMXSS issues are different if response content is different.
responseExisting = existingIssue.getHttpMessages(
)[0].getResponse()
analyzedResponseExisting = self.helpers.analyzeResponse(
responseExisting)
bodyOffsetExisting = analyzedResponseExisting.getBodyOffset()
responseBodyExisting = responseExisting.getResponse(
)[analyzedResponseExisting.getBodyOffset():].tostring()
responseNew = newIssue.getHttpMessages()[0].getResponse()
analyzedResponseNew = self.helpers.analyzeResponse(responseNew)
bodyOffsetNew = analyzedResponseNew.getBodyOffset()
responseBodyNew = responseNew.getResponse(
)[analyzedResponseNew.getBodyOffset():].tostring()
if responseBodyExisting == responseBodyNew:
return -1
else:
return 0
elif newIssue.getIssueName(
) == issueNameRedirectFromHTTP2HTTPS: # Redirection issues are different if target URLs differ
if existingIssue.getIssueDetail() == newIssue.getIssueDetail():
return -1
else:
return 0
else: # In all other cases: keep existing issue
return -1
return 0
for i in range(n):
zx = random.random()
zy = random.random()
if zx * zx + zy * zy < 1:
hits = hits + 1
setColor("red")
else:
setColor("green")
point(zx, zy)
return hits
lbl1 = JLabel("Number of drops: ")
lbl2 = JLabel(" PI = ")
tf1 = JTextField(6)
tf2 = JTextField(10)
btn1 = JButton("OK", actionListener = actionCallback)
makeGPanel("Monte Carlo Simulation", -0.1, 1.1, -0.1, 1.1)
createGUI()
tf1.setText("10000")
init()
while True:
putSleep()
init()
n = int(tf1.getText())
k = doIt(n)
pi = 4 * k / n
tf2.setText(str(pi))
class TimesketchSettingsWithUISettingsPanel(IngestModuleIngestJobSettingsPanel):
# Note, we can't use a self.settings instance variable.
# Rather, self.local_settings is used.
# https://wiki.python.org/jython/UserGuide#javabean-properties
# Jython Introspector generates a property - 'settings' on the basis
# of getSettings() defined in this class. Since only getter function
# is present, it creates a read-only 'settings' property. This auto-
# generated read-only property overshadows the instance-variable -
# 'settings'
# We get passed in a previous version of the settings so that we can
# prepopulate the UI
def __init__(self, settings):
self.local_settings = settings
self.tag_list = []
self.initComponents()
self.customizeComponents()
self.path_to_Timesketch_exe = os.path.join(os.path.dirname(os.path.abspath(__file__)), "Timesketch_api.exe")
# Check to see if the Timesketch server is available and you can talk to it
def Check_Server(self, e):
pipe = Popen([self.path_to_Timesketch_exe, self.Protocol_TF.getText(),self.IP_Address_TF.getText(), self.Port_Number_TF.getText(), "Timesketch_status" ], stdout=PIPE, stderr=PIPE)
out_text = pipe.communicate()[0]
self.Error_Message.setText("Timesketch Status is " + out_text)
#self.log(Level.INFO, "Timesketch Status is ==> " + out_text)
def setIPAddress(self, event):
self.local_settings.setSetting('ipAddress', self.IP_Address_TF.getText())
def setPortNumber(self, event):
self.local_settings.setSetting('portNumber', self.Port_Number_TF.getText())
def setUserName(self, event):
self.local_settings.setSetting('userName', self.userName_TF.getText())
def setPassword(self, event):
self.local_settings.setSetting('password', self.password_TF.getText())
def setsketchName(self, event):
self.local_settings.setSetting('sketchName', self.sketchName_TF.getText())
def setsketchDescription(self, event):
self.local_settings.setSetting('sketchDescription', self.sketchDescription_TF.getText())
# Create the initial data fields/layout in the UI
def initComponents(self):
self.panel0 = JPanel()
self.rbgPanel0 = ButtonGroup()
self.gbPanel0 = GridBagLayout()
self.gbcPanel0 = GridBagConstraints()
self.panel0.setLayout( self.gbPanel0 )
self.Label_2 = JLabel("Timesketch IP Address")
self.Label_2.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 5
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_2, self.gbcPanel0 )
self.panel0.add( self.Label_2 )
self.IP_Address_TF = JTextField(20, focusLost=self.setIPAddress)
self.IP_Address_TF.setEnabled(True)
self.gbcPanel0.gridx = 4
self.gbcPanel0.gridy = 5
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.IP_Address_TF, self.gbcPanel0 )
self.panel0.add( self.IP_Address_TF )
self.Blank_2 = JLabel( " ")
self.Blank_2.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 7
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_2, self.gbcPanel0 )
self.panel0.add( self.Blank_2 )
self.Label_3 = JLabel("Port Number")
self.Label_3.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 9
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_3, self.gbcPanel0 )
self.panel0.add( self.Label_3 )
self.Port_Number_TF = JTextField(20, focusLost=self.setPortNumber)
self.Port_Number_TF.setEnabled(True)
self.gbcPanel0.gridx = 4
self.gbcPanel0.gridy = 9
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Port_Number_TF, self.gbcPanel0 )
self.panel0.add( self.Port_Number_TF )
self.Blank_3 = JLabel( " ")
self.Blank_3.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 11
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_3, self.gbcPanel0 )
self.panel0.add( self.Blank_3 )
self.Label_4 = JLabel("User Name")
self.Label_4.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 13
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_4, self.gbcPanel0 )
self.panel0.add( self.Label_4 )
self.userName_TF = JTextField(20, focusLost=self.setUserName)
self.userName_TF.setEnabled(True)
self.gbcPanel0.gridx = 4
self.gbcPanel0.gridy = 13
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.userName_TF, self.gbcPanel0 )
self.panel0.add( self.userName_TF )
self.Blank_4 = JLabel( " ")
self.Blank_4.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 15
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_4, self.gbcPanel0 )
self.panel0.add( self.Blank_4 )
self.Label_5 = JLabel("Password")
self.Label_5.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 17
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_5, self.gbcPanel0 )
self.panel0.add( self.Label_5 )
self.password_TF = JPasswordField(20, focusLost=self.setPassword)
# self.password_TF = JTextField(20)
self.password_TF.setEnabled(True)
self.gbcPanel0.gridx = 4
self.gbcPanel0.gridy = 17
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.password_TF, self.gbcPanel0 )
self.panel0.add( self.password_TF )
self.Blank_5 = JLabel( " ")
self.Blank_5.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 19
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_5, self.gbcPanel0 )
self.panel0.add( self.Blank_5 )
self.Label_6 = JLabel("Sketch Name")
self.Label_6.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 21
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_6, self.gbcPanel0 )
self.panel0.add( self.Label_6 )
self.sketchName_TF = JTextField(20, focusLost=self.setsketchName)
self.sketchName_TF.setEnabled(True)
self.gbcPanel0.gridx = 4
self.gbcPanel0.gridy = 21
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.sketchName_TF, self.gbcPanel0 )
self.panel0.add( self.sketchName_TF )
self.Blank_6 = JLabel( " ")
self.Blank_6.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 23
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_6, self.gbcPanel0 )
self.panel0.add( self.Blank_6 )
self.Label_7 = JLabel("Sketch Description")
self.Label_7.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 25
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_7, self.gbcPanel0 )
self.panel0.add( self.Label_7 )
self.sketchDescription_TF = JTextField(20, focusLost=self.setsketchDescription)
self.sketchDescription_TF.setEnabled(True)
self.gbcPanel0.gridx = 4
self.gbcPanel0.gridy = 25
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.sketchDescription_TF, self.gbcPanel0 )
self.panel0.add( self.sketchDescription_TF )
self.Blank_7 = JLabel( " ")
self.Blank_7.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 27
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_7, self.gbcPanel0 )
self.panel0.add( self.Blank_7 )
# self.Check_Server_Status_BTN = JButton( "Check Server Status", actionPerformed=self.Check_Server)
# self.Check_Server_Status_BTN.setEnabled(True)
# self.rbgPanel0.add( self.Save_Settings_BTN )
# self.gbcPanel0.gridx = 2
# self.gbcPanel0.gridy = 29
# self.gbcPanel0.gridwidth = 1
# self.gbcPanel0.gridheight = 1
# self.gbcPanel0.fill = GridBagConstraints.BOTH
# self.gbcPanel0.weightx = 1
# self.gbcPanel0.weighty = 0
# self.gbcPanel0.anchor = GridBagConstraints.NORTH
# self.gbPanel0.setConstraints( self.Check_Server_Status_BTN, self.gbcPanel0 )
# self.panel0.add( self.Check_Server_Status_BTN )
self.Error_Message = JLabel( "")
self.Error_Message.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 31
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Error_Message, self.gbcPanel0 )
self.panel0.add( self.Error_Message )
self.add(self.panel0)
# Custom load any data field and initialize the values
def customizeComponents(self):
#self.Exclude_File_Sources_CB.setSelected(self.local_settings.getExclude_File_Sources())
#self.Run_Timesketch_CB.setSelected(self.local_settings.getRun_Timesketch())
#self.Import_Timesketch_CB.setSelected(self.local_settings.getImport_Timesketch())
#self.check_Database_entries()
self.IP_Address_TF.setText(self.local_settings.getSetting('ipAddress'))
self.Port_Number_TF.setText(self.local_settings.getSetting('portNumber'))
self.userName_TF.setText(self.local_settings.getSetting('userName'))
self.password_TF.setText(self.local_settings.getSetting('password'))
self.sketchName_TF.setText(Case.getCurrentCase().getNumber())
self.sketchDescription_TF.setText(Case.getCurrentCase().getName())
self.local_settings.setSetting('sketchName', self.sketchName_TF.getText())
self.local_settings.setSetting('sketchDescription', self.sketchDescription_TF.getText())
# Return the settings used
def getSettings(self):
return self.local_settings
class ProtoBufEditorTab(burp.IMessageEditorTab):
"""Tab in interceptor/repeater for editing protobuf message.
Decodes them to JSON and back.
The message type is attached to this object.
"""
def __init__(self, extension, controller, editable, callbacks):
self._callbacks = callbacks
self._extension = extension
self._callbacks = extension.callbacks
self._helpers = extension.helpers
self._controller = controller
self._text_editor = self._callbacks.createTextEditor()
self._text_editor.setEditable(editable)
self._editable = editable
self._last_valid_type_index = None
self._filtered_message_model = FilteredMessageModel(
extension.known_message_model, self._callbacks
)
self._type_list_component = JList(self._filtered_message_model)
self._type_list_component.setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
self._type_list_component.addListSelectionListener(TypeListListener(self))
self._new_type_field = JTextField()
self._component = JSplitPane(JSplitPane.HORIZONTAL_SPLIT)
self._component.setLeftComponent(self._text_editor.getComponent())
self._component.setRightComponent(self.createButtonPane())
self._component.setResizeWeight(0.95)
self.message_type = None
self._is_request = None
self._encoder = None
self._original_json = None
self._original_typedef = None
self._last_set_json = ""
self._content_info = None
self._request_content_info = None
self._request = None
self._original_content = None
def getTabCaption(self):
"""Return message tab caption"""
return "Protobuf"
def getMessage(self):
"""Transform the JSON format back to the binary protobuf message"""
try:
if self.message_type is None or not self.isModified():
return self._original_content
json_data = self._text_editor.getText().tostring()
protobuf_data = blackboxprotobuf.protobuf_from_json(
json_data, self.message_type
)
protobuf_data = self.encodePayload(protobuf_data)
if "set_protobuf_data" in dir(user_funcs):
result = user_funcs.set_protobuf_data(
protobuf_data,
self._original_content,
self._is_request,
self._content_info,
self._helpers,
self._request,
self._request_content_info,
)
if result is not None:
return result
headers = self._content_info.getHeaders()
return self._helpers.buildHttpMessage(headers, str(protobuf_data))
except Exception as exc:
self._callbacks.printError(traceback.format_exc())
JOptionPane.showMessageDialog(
self._component, "Error encoding protobuf: " + str(exc)
)
# Resets state
return self._original_content
def setMessage(self, content, is_request, retry=True):
"""Get the data from the request/response and parse into JSON.
sets self.message_type
"""
# Save original content
self._original_content = content
if is_request:
self._content_info = self._helpers.analyzeRequest(
self._controller.getHttpService(), content
)
else:
self._content_info = self._helpers.analyzeResponse(content)
self._is_request = is_request
self._request = None
self._request_content_info = None
if not is_request:
self._request = self._controller.getRequest()
self._request_content_info = self._helpers.analyzeRequest(
self._controller.getHttpService(), self._request
)
# how we remember which message type correlates to which endpoint
self._message_hash = self.getMessageHash()
# Try to find saved messsage type
self.message_type = None
self.message_type_name = None
if self._message_hash in self._extension.saved_types:
typename = self._extension.saved_types[self._message_hash]
if typename in default_config.known_types:
self.message_type_name = typename
self.message_type = default_config.known_types[typename]
else:
del self._extension.saved_types[self._message_hash]
try:
protobuf_data = None
if "get_protobuf_data" in dir(user_funcs):
protobuf_data = user_funcs.get_protobuf_data(
content,
is_request,
self._content_info,
self._helpers,
self._request,
self._request_content_info,
)
if protobuf_data is None:
protobuf_data = content[self._content_info.getBodyOffset() :].tostring()
protobuf_data = self.decodePayload(protobuf_data)
# source_typedef will be the original, updatable version of the dict
# TODO fix this hack
self._original_data = protobuf_data
self._filtered_message_model.set_new_data(protobuf_data)
self._source_typedef = self.message_type
json_data, self.message_type = blackboxprotobuf.protobuf_to_json(
protobuf_data, self.message_type
)
self._original_json = json_data
self._original_typedef = self.message_type
self._last_set_json = str(json_data)
self._text_editor.setText(json_data)
success = True
except Exception as exc:
success = False
self._callbacks.printError(
"Got error decoding protobuf binary: " + traceback.format_exc()
)
# Bring out of exception handler to avoid nexting handlers
if not success:
if self._message_hash in self._extension.saved_types:
del self._extension.saved_types[self._message_hash]
self.setMessage(content, is_request, False)
self._text_editor.setText("Error decoding protobuf")
if self.message_type_name:
self.forceSelectType(self.message_type_name)
def decodePayload(self, payload):
"""Add support for decoding a few default methods. Including Base64 and GZIP"""
if payload.startswith(bytearray([0x1F, 0x8B, 0x08])):
gzip_decompress = zlib.decompressobj(-zlib.MAX_WBITS)
self._encoder = "gzip"
return gzip_decompress.decompress(payload)
# Try to base64 decode
try:
protobuf = base64.b64decode(payload, validate=True)
self._encoder = "base64"
return protobuf
except Exception as exc:
pass
# try decoding as a gRPC payload: https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md
# we're naiively handling only uncompressed payloads
if len(payload) > 1 + 4 and payload.startswith(
bytearray([0x00])
): # gRPC has 1 byte flag + 4 byte length
(message_length,) = struct.unpack_from(">I", payload[1:])
if len(payload) == 1 + 4 + message_length:
self._encoder = "gRPC"
return payload[1 + 4 :]
# try:
# protobuf = base64.urlsafe_b64decode(payload)
# self._encoder = 'base64_url'
# return protobuf
# except Exception as exc:
# pass
self._encoder = None
return payload
def encodePayload(self, payload):
"""If we detected an encoding like gzip or base64 when decoding, redo
that encoding step here
"""
if self._encoder == "base64":
return base64.b64encode(payload)
elif self._encoder == "base64_url":
return base64.urlsafe_b64encode(payload)
elif self._encoder == "gzip":
gzip_compress = zlib.compressobj(-1, zlib.DEFLATED, -zlib.MAX_WBITS)
self._encoder = "gzip"
return gzip_compress.compress(payload)
elif self._encoder == "gRPC":
message_length = struct.pack(">I", len(payload))
return bytearray([0x00]) + bytearray(message_length) + payload
else:
return payload
def getSelectedData(self):
"""Get text currently selected in message"""
return self._text_editor.getSelectedText()
def getUiComponent(self):
"""Return Java AWT component for this tab"""
return self._component
def isEnabled(self, content, is_request):
"""Try to detect a protobuf in the message to enable the tab. Defaults
to content-type header of 'x-protobuf'. User overridable
"""
# TODO implement some more default checks
if is_request:
info = self._helpers.analyzeRequest(content)
else:
info = self._helpers.analyzeResponse(content)
if "detect_protobuf" in dir(user_funcs):
result = user_funcs.detect_protobuf(
content, is_request, info, self._helpers
)
if result is not None:
return result
# Bail early if there is no body
if info.getBodyOffset() == len(content):
return False
protobuf_content_types = [
"protobuf",
"grpc",
]
# Check all headers for x-protobuf
for header in info.getHeaders():
if "content-type" in header.lower():
for protobuf_content_type in protobuf_content_types:
if protobuf_content_type in header.lower():
return True
return False
def isModified(self):
"""Return if the message was modified"""
return self._text_editor.isTextModified()
def createButtonPane(self):
"""Create a new button pane for the message editor tab"""
self._button_listener = EditorButtonListener(self)
panel = JPanel()
panel.setLayout(BoxLayout(panel, BoxLayout.Y_AXIS))
panel.setBorder(EmptyBorder(5, 5, 5, 5))
panel.add(Box.createRigidArea(Dimension(0, 5)))
type_scroll_pane = JScrollPane(self._type_list_component)
type_scroll_pane.setMaximumSize(Dimension(200, 100))
type_scroll_pane.setMinimumSize(Dimension(150, 100))
panel.add(type_scroll_pane)
panel.add(Box.createRigidArea(Dimension(0, 3)))
new_type_panel = JPanel()
new_type_panel.setLayout(BoxLayout(new_type_panel, BoxLayout.X_AXIS))
new_type_panel.add(self._new_type_field)
new_type_panel.add(Box.createRigidArea(Dimension(3, 0)))
new_type_panel.add(
self.createButton(
"New", "new-type", "Save this message's type under a new name"
)
)
new_type_panel.setMaximumSize(Dimension(200, 20))
new_type_panel.setMinimumSize(Dimension(150, 20))
panel.add(new_type_panel)
button_panel = JPanel()
button_panel.setLayout(FlowLayout())
if self._editable:
button_panel.add(
self.createButton(
"Validate", "validate", "Validate the message can be encoded."
)
)
button_panel.add(
self.createButton("Edit Type", "edit-type", "Edit the message type")
)
button_panel.add(
self.createButton(
"Reset Message", "reset", "Reset the message and undo changes"
)
)
button_panel.add(
self.createButton(
"Clear Type", "clear-type", "Reparse the message with an empty type"
)
)
button_panel.setMinimumSize(Dimension(100, 200))
button_panel.setPreferredSize(Dimension(200, 1000))
panel.add(button_panel)
return panel
def createButton(self, text, command, tooltip):
"""Create a new button with the given text and command"""
button = JButton(text)
button.setAlignmentX(Component.CENTER_ALIGNMENT)
button.setActionCommand(command)
button.addActionListener(self._button_listener)
button.setToolTipText(tooltip)
return button
def validateMessage(self):
"""Callback for validate button. Attempts to encode the message with
the current type definition
"""
try:
json_data = self._text_editor.getText().tostring()
blackboxprotobuf.protobuf_from_json(json_data, self.message_type)
# If it works, save the message
self._original_json = json_data
self._original_typedef = self.message_type
except Exception as exc:
JOptionPane.showMessageDialog(self._component, str(exc))
self._callbacks.printError(traceback.format_exc())
def resetMessage(self):
"""Drop any changes and reset the message. Callback for "reset"
button
"""
self._last_set_json = str(self._original_json)
self._text_editor.setText(self._original_json)
self.message_type = self._original_typedef
def getMessageHash(self):
"""Compute an "identifier" for the message which is used for sticky
type definitions. User modifiable
"""
message_hash = None
if "hash_message" in dir(user_funcs):
message_hash = user_funcs.hash_message(
self._original_content,
self._is_request,
self._content_info,
self._helpers,
self._request,
self._request_content_info,
)
if message_hash is None:
# Base it off just the URL and request/response
content_info = (
self._content_info if self._is_request else self._request_content_info
)
url = content_info.getUrl().getPath()
message_hash = ":".join([url, str(self._is_request)])
return message_hash
def forceSelectType(self, typename):
index = self._filtered_message_model.get_type_index(typename)
if index is not None:
self._last_valid_type_index = index
self._type_list_component.setSelectedIndex(index)
def updateTypeSelection(self):
"""Apply a new typedef based on the selected type in the type list"""
# Check if something is selected
if self._type_list_component.isSelectionEmpty():
self._last_valid_type_index = None
del self._extension.saved_types[self._message_hash]
return
# TODO won't actually work right if we delete the type we're using a
# new type is now in the index
if self._last_valid_type_index == self._type_list_component.getSelectedIndex():
# hasn't actually changed since last time we tried
# otherwise can trigger a second time when we call setSelectedIndex below on failure
return
type_name = self._type_list_component.getSelectedValue()
# try to catch none here...
if not type_name or type_name not in default_config.known_types:
return
try:
self.applyType(default_config.known_types[type_name])
except BlackboxProtobufException as exc:
self._callbacks.printError(traceback.format_exc())
if isinstance(exc, EncoderException):
JOptionPane.showMessageDialog(
self._component,
"Error encoding protobuf with previous type: %s" % (exc),
)
elif isinstance(exc, DecoderException):
JOptionPane.showMessageDialog(
self._component,
"Error encoding protobuf with type %s: %s" % (type_name, exc),
)
# decoder exception means it doesn't match the message that was sucessfully encoded by the prev type
self._filtered_message_model.remove_type(type_name)
if self._last_valid_type_index is not None:
type_name = self._type_list_component.setSelectedIndex(
self._last_valid_type_index
)
else:
self._type_list_component.clearSelection()
return
self._extension.saved_types[self._message_hash] = type_name
self._last_valid_type_index = self._type_list_component.getSelectedIndex()
def editType(self, typedef):
"""Apply the new typedef. Use dict.update to change the original
dictionary, so we also update the anonymous cached definition and ones
stored in known_messages"""
# TODO this is kind of an ugly hack. Should redo how these are referenced
# probably means rewriting a bunch of the editor
old_source = self._source_typedef
old_source.clear()
old_source.update(typedef)
self.applyType(old_source)
def applyType(self, typedef):
"""Apply a new typedef to the message. Throws an exception if type is invalid."""
# store a reference for later mutation?
self._source_typedef = typedef
# Convert to protobuf as old type and re-interpret as new type
old_message_type = self.message_type
json_data = self._text_editor.getText().tostring()
protobuf_data = blackboxprotobuf.protobuf_from_json(json_data, old_message_type)
new_json, message_type = blackboxprotobuf.protobuf_to_json(
str(protobuf_data), typedef
)
# Should exception out before now if there is an issue
self.message_type = message_type
# if the json data was modified, then re-check our types
if json_data != self._last_set_json:
self._filtered_message_model.set_new_data(protobuf_data)
self._last_set_json = str(new_json)
self._text_editor.setText(str(new_json))
def saveAsNewType(self):
"""Copy the current type into known_messages"""
name = self._new_type_field.getText().strip()
if not NAME_REGEX.match(name):
JOptionPane.showMessageDialog(
self._component,
"%s is not a valid "
"message name. Message names should be alphanumeric." % name,
)
return
if name in default_config.known_types:
JOptionPane.showMessageDialog(
self._component, "Message name %s is " "already taken." % name
)
return
# Do a deep copy on the dictionary so we don't accidentally modify others
default_config.known_types[name] = copy.deepcopy(self.message_type)
# update the list of messages. This should trickle down to known message model
self._extension.known_message_model.addElement(name)
self._new_type_field.setText("")
self._extension.saved_types[self._message_hash] = name
# force select our new type
self.forceSelectType(name)
def clearType(self):
self.applyType({})
self._type_list_component.clearSelection()
self._new_type_field.setText("")
def open_typedef_window(self):
self._extension.open_typedef_editor(self.message_type, self.editType)
class BurpExtender(IBurpExtender,ITab,IHttpListener):
def registerExtenderCallbacks(self,callbacks):
self.callbacks = callbacks
self.helpers = callbacks.getHelpers()
self.callbacks.setExtensionName("KkMultiProxy")
self.PROXY_LIST = []
self.jPanel = JPanel()
boxVertical = Box.createVerticalBox()
boxHorizontal = Box.createHorizontalBox()
boxHorizontal.add(JButton("File",actionPerformed=self.getFile))
self.FileText = JTextField("")
boxHorizontal.add(self.FileText)
boxVertical.add(boxHorizontal)
TableHeader = ('IP','PORT')
TableModel = DefaultTableModel(self.PROXY_LIST,TableHeader)
self.Table = JTable(TableModel)
boxVertical.add(self.Table)
boxHorizontal = Box.createHorizontalBox()
boxHorizontal.add(JButton("Add",actionPerformed=self.addIP))
boxHorizontal.add(JButton("Delete",actionPerformed=self.deleteIP))
boxHorizontal.add(JButton("Save",actionPerformed=self.saveIP))
boxVertical.add(boxHorizontal)
self.jPanel.add(boxVertical)
self.callbacks.addSuiteTab(self)
self.callbacks.registerHttpListener(self)
return
def getFile(self,button):
dlg = JFileChooser()
result = dlg.showOpenDialog(None)
if result == JFileChooser.APPROVE_OPTION:
f = dlg.getSelectedFile()
path = f.getPath()
self.FileText.setText(path)
try:
self.getIPList(path)
except:
exit(0)
def addIP(self,button):
#chooser = JFileChooser()
#chooser.showOpenDialog(None)
demo = DialogDemo(self.Table)
def deleteIP(self,button):
selectRows = len(self.Table.getSelectedRows())
TableModel = self.Table.getModel()
if selectRows:
selectedRowIndex = self.Table.getSelectedRow()
TableModel.removeRow(selectedRowIndex)
def saveIP(self,button):
TableModel = self.Table.getModel()
rowCount = TableModel.getRowCount()
result_str = ""
for i in range(rowCount):
if i == 0:
result_str+=TableModel.getValueAt(i,0)+':'+TableModel.getValueAt(i,1)
else:
result_str+='|'+TableModel.getValueAt(i,0)+':'+TableModel.getValueAt(i,1)
print result_str
f = open(self.FileText.getText(),'w+')
f.write(result_str)
f.close()
def getTabCaption(self):
return "MultiProxy"
def getUiComponent(self):
return self.jPanel
def processHttpMessage(self,toolFlag,messageIsRequest,messageInfo):
if messageIsRequest:
httpService = messageInfo.getHttpService()
print httpService.getHost()
# if the host is HOST_FROM, change it to HOST_TO
i = randint(0,len(self.TableDatas)-1)
messageInfo.setHttpService(self.helpers.buildHttpService(self.PROXY_LIST[i]['ip'], self.PROXY_LIST[i]['port'], httpService.getProtocol()))
print messageInfo.getHttpService().getHost()
def getIPList(self,path):
f = open(path,'r+')
content = f.read()
f.close()
if content:
ip_array = content.split('|')
for _ip in ip_array:
ip = _ip.split(':')[0]
port = _ip.split(':')[1]
self.PROXY_LIST.append([ip,port])
print self.PROXY_LIST
class ConfigurationPanel(JPanel, PropertyChangeListener):
def __init__(self):
''' Configuration Panel '''
# pconfig = JPanel(GridBagLayout())
# pconfig.setSize(Dimension(500,300))
self.setLayout(GridBagLayout())
# super(self,GridBagLayout())
self.setSize(Dimension(500,300))
''' fila 1 '''
label = JLabel('Configuration panel')
c1 = GridBagConstraints()
c1.fill = GridBagConstraints.HORIZONTAL
c1.weightx = 0.5
c1.gridwidth = 4
c1.gridx = 0
c1.gridy = 0
self.add(label, c1)
''' fila 2 '''
self.radioBtnOMC = JRadioButton('OpenModelica')
c2 = GridBagConstraints()
c2.fill = GridBagConstraints.HORIZONTAL
c2.weightx = 0.5
c2.gridx = 0
c2.gridy = 1
self.add(self.radioBtnOMC, c2)
self.radioBtnJM = JRadioButton('JModelica')
c3 = GridBagConstraints()
c3.fill = GridBagConstraints.HORIZONTAL
c3.weightx = 0.5
c3.gridx = 1
c3.gridy = 1
self.add(self.radioBtnJM, c3)
self.radioBtnDY = JRadioButton('Dymola')
c4 = GridBagConstraints()
c4.fill = GridBagConstraints.HORIZONTAL
c4.weightx = 0.5
c4.gridx = 2
c4.gridy = 1
self.add(self.radioBtnDY, c4)
rbBtnGroup = ButtonGroup()
rbBtnGroup.add(self.radioBtnOMC)
rbBtnGroup.add(self.radioBtnJM)
rbBtnGroup.add(self.radioBtnDY)
''' fila 2 '''
label = JLabel('Start time')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 0
c.gridy = 2
self.add(label, c)
self.txtstart= JTextField('0')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 1
c.gridy = 2
self.add(self.txtstart, c)
label = JLabel('Stop time')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 2
c.gridy = 2
self.add(label, c)
self.txtstop= JTextField('0')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 3
c.gridy = 2
self.add(self.txtstop, c)
''' fila 3 '''
label = JLabel('Solver')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 0
c.gridy = 3
self.add(label, c)
self.cbsolver= JComboBox(['dassl','rkfix2'])
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 1
c.gridy = 3
self.add(self.cbsolver, c)
label = JLabel('Algorithm (JM)')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 2
c.gridy = 3
self.add(label, c)
self.cbalgorithm= JComboBox(['AssimuloAlg'])
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 3
c.gridy = 3
self.add(self.cbalgorithm, c)
''' fila 4 '''
label = JLabel('Interval')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 0
c.gridy = 4
self.add(label, c)
self.txtinterval= JTextField('0')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 1
c.gridy = 4
self.add(self.txtinterval, c)
''' fila 5 '''
label = JLabel('Tolerance')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 0
c.gridy = 5
self.add(label, c)
self.txttolerance= JTextField('0')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 1
c.gridy = 5
self.add(self.txttolerance, c)
''' fila 6 '''
label = JLabel('Output format')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 0
c.gridy = 6
self.add(label, c)
self.cboutformat= JComboBox(['.mat','.h5','.csv'])
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 1
c.gridy = 6
self.add(self.cboutformat, c)
label = JLabel('Initialize (JM)')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 2
c.gridy = 6
self.add(label, c)
self.cbinitialize= JComboBox(['True','False'])
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridx = 3
c.gridy = 6
self.add(self.cbinitialize, c)
''' fila 7 '''
bSaveCfg= JButton('Save Configuration', actionPerformed= self.saveConfiguration)
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridwidth = 2
c.gridx = 0
c.gridy = 7
self.add(bSaveCfg, c)
self.bSimulation= JButton('Load Configuration', actionPerformed= self.loadConfiguration)
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 0.5
c.gridwidth = 2
c.gridx = 2
c.gridy = 7
self.add(self.bSimulation, c)
''' fila 8 '''
self.bSimulation= JButton('Simulate', actionPerformed= self.startSimlation)
self.bSimulation.enabled= 0
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 1
c.gridwidth = 4
c.gridx = 0
c.gridy = 8
self.add(self.bSimulation, c)
''' file 9 '''
simProgress= JProgressBar(0, self.getWidth(), value=0, stringPainted=True)
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 1
c.gridwidth = 4
c.gridx = 0
c.gridy = 9
self.add(simProgress, c)
''' fila 10 '''
self.lblResult= JLabel('Simulation information')
c = GridBagConstraints()
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 1
c.gridwidth = 4
c.gridx = 0
c.gridy = 10
self.add(self.lblResult, c)
def startSimlation(self, event):
"Invoked when the user presses the start button"
self.bSimulation.enabled = False
#Instances of javax.swing.SwingWorker are not reusable, so
#we create new instances as needed.
self.simtask = SimulationTask(self)
# self.simtask.addPropertyChangeListener(self)
self.simtask.execute()
def saveConfiguration(self,event):
if self.radioBtnOMC.isSelected() or self.radioBtnDY.isSelected():
self.config= SimulationConfigOMCDY()
self.config.set_starttime(self.txtstart.getText())
self.config.set_stoptime(self.txtstop.getText())
self.config.set_tolerance(self.txttolerance.getText())
self.config.set_intervals(self.txtinterval.getText())
self.config.set_method(self.cbsolver.selectedItem)
self.config.set_outputformat(self.cboutformat.selectedItem)
if self.radioBtnOMC.isSelected():
nomfile= './config/simConfigurationOMC.properties'
if self.radioBtnDY.isSelected():
nomfile= './config/simConfigurationDY.properties'
self.config.save_Properties(nomfile, 'Simulation Configuration')
if self.radioBtnJM.isSelected():
self.config= SimulationConfigJM()
self.config.set_starttime(self.txtstart.getText())
self.config.set_stoptime(self.txtstop.getText())
self.config.set_intervals(self.txtinterval.text)
self.config.set_method(self.cbsolver.selectedItem)
self.config.set_algorithm(self.cbalgorithm.selectedItem)
self.config.set_initialization(self.cbinitialize.selectedItem)
self.config.set_outputformat(self.cboutformat.selectedItem)
nomfile= './config/simConfigurationJM.properties'
self.config.save_Properties(nomfile, 'Simulation Configuration')
self.bSimulation.enabled= 1
def loadConfiguration(self, event):
if self.radioBtnOMC.isSelected() or self.radioBtnDY.isSelected():
self.config= SimulationConfigOMCDY()
self.config.load_Properties('./config/simConfigurationOMC.properties')
self.txtstart.setText(self.config.get_starttime())
self.txtstop.setText(self.config.get_stoptime())
self.txttolerance.setText(self.config.get_tolerance())
self.txtinterval.setText(self.config.get_intervals())
self.cbsolver.selectedItem= self.config.get_method()
self.cboutformat.selectedItem= self.config.get_outputformat()
if self.radioBtnJM.isSelected():
self.config= SimulationConfigJM()
self.config.load_Properties('./config/simConfigurationJM.properties')
self.txtstart.setText(self.config.get_starttime())
self.txtstop.setText(self.config.get_stoptime())
self.txtinterval.setText(self.config.get_intervals())
self.cbsolver.selectedItem= self.config.get_method()
self.cbalgorithm.selectedItem= self.config.get_algorithm()
self.cbinitialize.selectedItem= self.config.get_initialization()
# self.cboutformat.selectedItem= self.config.get_outputformat()
self.bSimulation.enabled= 1
def __init__(self, imgData):
n = imgData.size()
win = JFrame("Point Marker Panel")
win.setPreferredSize(Dimension(350, 590))
win.setSize(win.getPreferredSize())
pan = JPanel()
pan.setLayout(BoxLayout(pan, BoxLayout.Y_AXIS))
win.getContentPane().add(pan)
progressPanel = JPanel()
progressPanel.setLayout(BoxLayout(progressPanel, BoxLayout.Y_AXIS))
positionBar = JProgressBar()
positionBar.setMinimum(0)
positionBar.setMaximum(n)
positionBar.setStringPainted(True)
progressPanel.add(Box.createGlue())
progressPanel.add(positionBar)
progressBar = JProgressBar()
progressBar.setMinimum(0)
progressBar.setMaximum(n)
progressBar.setStringPainted(True)
progressPanel.add(progressBar)
progressPanel.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 10))
pan.add(progressPanel)
pan.add(Box.createRigidArea(Dimension(5, 5)))
savePanel = JPanel()
savePanel.setLayout(BoxLayout(savePanel, BoxLayout.Y_AXIS))
saveMessageLabel = JLabel("<html><u>Save Often</u></html>")
savePanel.add(saveMessageLabel)
savePanel.setAlignmentX(Component.CENTER_ALIGNMENT)
savePanel.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 10))
pan.add(savePanel)
# pan.add(saveMessageLabel)
pan.add(Box.createRigidArea(Dimension(5, 5)))
calPanel = JPanel()
calPanel.setLayout(BoxLayout(calPanel, BoxLayout.Y_AXIS))
calPanelIn = JPanel()
calPanelIn.setLayout(BoxLayout(calPanelIn, BoxLayout.X_AXIS))
pixelSizeText = JTextField(12)
pixelSizeText.setHorizontalAlignment(JTextField.RIGHT)
# pixelSizeText.setMaximumSize(pixelSizeText.getPreferredSize())
unitText = JTextField(10)
# unitText.setMaximumSize(unitText.getPreferredSize())
pixelSizeText.setText("Enter Pixel Size Here")
calPanelIn.add(pixelSizeText)
unitText.setText("Unit")
calPanelIn.add(unitText)
calPanelIn.setAlignmentX(Component.CENTER_ALIGNMENT)
calPanelIn.setBorder(
BorderFactory.createTitledBorder("Custom Calibration"))
calPanel.add(calPanelIn)
calPanelIn.setAlignmentX(Component.CENTER_ALIGNMENT)
calPanel.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 10))
pan.add(calPanel)
pan.add(Box.createRigidArea(Dimension(5, 5)))
helpPanel = JPanel()
helpPanel.setLayout(BoxLayout(helpPanel, BoxLayout.Y_AXIS))
helpLable = JLabel("<html><ul>\
<li>Focus on Image Window</li>\
<li>Select multi-point Tool</li>\
<li>Click to Draw Points</li>\
<li>Drag to Move Points</li>\
<li>\"Alt\" + Click to Erase Points</li>\
<li>Optional: Customize Calibration Above\
and Refresh Images\
(won't be written to files)</li>\
</html>")
helpLable.setBorder(BorderFactory.createTitledBorder("Usage"))
keyTagOpen = "<span style=\"background-color: #FFFFFF\"><b><kbd>"
keyTagClose = "</kbd></b></span>"
keyLable = JLabel("<html><ul>\
<li>Next Image --- " + keyTagOpen + "<" + \
keyTagClose + "</li>\
<li>Previous Image --- " + keyTagOpen + ">" + \
keyTagClose + "</li>\
<li>Save --- " + keyTagOpen + "`" + keyTagClose + \
" (upper-left to TAB key)</li>\
<li>Next Unmarked Image --- " + keyTagOpen + \
"TAB" + keyTagClose + "</li></ul>\
</html>" )
keyLable.setBorder(
BorderFactory.createTitledBorder("Keyboard Shortcuts"))
helpPanel.add(helpLable)
helpPanel.add(keyLable)
helpPanel.setAlignmentX(Component.CENTER_ALIGNMENT)
helpPanel.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 10))
pan.add(helpPanel)
# pan.add(Box.createRigidArea(Dimension(0, 10)))
infoPanel = JPanel()
infoPanel.setLayout(BoxLayout(infoPanel, BoxLayout.Y_AXIS))
infoLabel = JLabel()
infoLabel.setBorder(BorderFactory.createTitledBorder("Project Info"))
infoPanel.add(infoLabel)
infoPanel.setAlignmentX(Component.CENTER_ALIGNMENT)
infoPanel.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 10))
pan.add(infoPanel)
win.setVisible(True)
self.imgData = imgData
self.win = win
# self.progressPanel = progressPanel
self.positionBar = positionBar
self.progressBar = progressBar
self.saveMessageLabel = saveMessageLabel
self.infoLabel = infoLabel
self.pixelSizeText = pixelSizeText
self.unitText = unitText
self.update()
class VolatilitySettingsWithUISettingsPanel(IngestModuleIngestJobSettingsPanel):
# Note, we can't use a self.settings instance variable.
# Rather, self.local_settings is used.
# https://wiki.python.org/jython/UserGuide#javabean-properties
# Jython Introspector generates a property - 'settings' on the basis
# of getSettings() defined in this class. Since only getter function
# is present, it creates a read-only 'settings' property. This auto-
# generated read-only property overshadows the instance-variable -
# 'settings'
# We get passed in a previous version of the settings so that we can
# prepopulate the UI
# TODO: Update this for your UI
def __init__(self, settings):
self.local_settings = settings
self.initComponents()
self.customizeComponents()
# When button to find file is clicked then open dialog to find the file and return it.
def Find_Dir(self, e):
chooseFile = JFileChooser()
filter = FileNameExtensionFilter("All", ["*.*"])
chooseFile.addChoosableFileFilter(filter)
#chooseFile.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
ret = chooseFile.showDialog(self.panel0, "Find Volatility Directory")
if ret == JFileChooser.APPROVE_OPTION:
file = chooseFile.getSelectedFile()
Canonical_file = file.getCanonicalPath()
#text = self.readPath(file)
self.local_settings.setSetting('Volatility_Directory', Canonical_file)
self.Program_Executable_TF.setText(Canonical_file)
def keyPressed(self, event):
self.local_settings.setProcessIDs(self.Process_Ids_To_Dump_TF.getText())
#self.Error_Message.setText(self.Process_Ids_To_Dump_TF.getText())
def checkBoxEvent(self, event):
if self.Check_Box.isSelected():
self.local_settings.setSetting('Flag', 'true')
else:
self.local_settings.setSetting('Flag', 'False')
# Create the initial data fields/layout in the UI
def initComponents(self):
self.panel0 = JPanel()
self.rbgPanel0 = ButtonGroup()
self.gbPanel0 = GridBagLayout()
self.gbcPanel0 = GridBagConstraints()
self.panel0.setLayout( self.gbPanel0 )
self.Error_Message = JLabel( "")
self.Error_Message.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 15
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Error_Message, self.gbcPanel0 )
self.panel0.add( self.Error_Message )
self.Label_1 = JLabel("Volatility Executable Directory")
self.Label_1.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 1
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_1, self.gbcPanel0 )
self.panel0.add( self.Label_1 )
self.Program_Executable_TF = JTextField(10)
self.Program_Executable_TF.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 3
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Program_Executable_TF, self.gbcPanel0 )
self.panel0.add( self.Program_Executable_TF )
self.Find_Program_Exec_BTN = JButton( "Find Dir", actionPerformed=self.Find_Dir)
self.Find_Program_Exec_BTN.setEnabled(True)
self.rbgPanel0.add( self.Find_Program_Exec_BTN )
self.gbcPanel0.gridx = 6
self.gbcPanel0.gridy = 3
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Find_Program_Exec_BTN, self.gbcPanel0 )
self.panel0.add( self.Find_Program_Exec_BTN )
self.Blank_1 = JLabel( " ")
self.Blank_1.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 5
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_1, self.gbcPanel0 )
self.panel0.add( self.Blank_1 )
self.Blank_3 = JLabel( " ")
self.Blank_3.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 7
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_3, self.gbcPanel0 )
self.panel0.add( self.Blank_3 )
self.Check_Box = JCheckBox("Extract and Create Memory Image from Hiberfile", actionPerformed=self.checkBoxEvent)
self.Blank_1.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 9
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Check_Box, self.gbcPanel0 )
self.panel0.add( self.Check_Box )
self.Blank_4 = JLabel( " ")
self.Blank_4.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 11
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_4, self.gbcPanel0 )
self.panel0.add( self.Blank_4 )
self.Label_3 = JLabel( "Message:")
self.Label_3.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 13
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_3, self.gbcPanel0 )
self.panel0.add( self.Label_3 )
self.add(self.panel0)
# Custom load any data field and initialize the values
def customizeComponents(self):
self.Check_Box.setSelected(self.local_settings.getSetting('Flag') == 'true')
self.Program_Executable_TF.setText(self.local_settings.getSetting('Volatility_Directory'))
#pass
# Return the settings used
def getSettings(self):
return self.local_settings
class ChannelPanel(JPanel):
gbc = GridBagConstraints()
def __init__(self):
JPanel.__init__(self)
self.setLayout(GridBagLayout())
self.setBorder(TitledBorder("Channel"))
# some helper constants
REL = GridBagConstraints.RELATIVE
REM = GridBagConstraints.REMAINDER
HORIZ = GridBagConstraints.HORIZONTAL
NW = GridBagConstraints.NORTHWEST
CENTER = GridBagConstraints.CENTER
# --- title
label = JLabel("Title:")
self.constrain(label, REL, REL, REL, 1,
HORIZ, CENTER, 1.0, 1.0,
2, 2, 2, 2)
self.field_title = JTextField()
self.field_title.setEditable(0)
self.constrain(self.field_title, REL, REL, REM, 1,
HORIZ, CENTER, 1.0, 1.0,
2, 2, 2, 2)
# --- description
label = JLabel("Description:")
self.constrain(label, REL, REL, REL, 1,
HORIZ, NW, 1.0, 1.0,
2, 2, 2, 2)
self.field_descr = JTextArea(3, 40)
self.field_descr.setEditable(0)
# wrap long lines
self.field_descr.setLineWrap(1)
# allow only full words to be wrapped
self.field_descr.setWrapStyleWord(1)
# ensure that the border look is the same
self.field_descr.setBorder(self.field_title.getBorder())
self.constrain(self.field_descr, REL, REL, REM, 1,
HORIZ, NW, 1.0, 1.0,
2, 2, 2, 2)
# --- location
label = JLabel("Location:")
self.constrain(label, REL, REL, REL, 1,
HORIZ, NW, 1.0, 1.0,
2, 2, 2, 2)
self.field_location = JTextField()
self.constrain(self.field_location, REL, REL, REM, REL,
HORIZ, NW, 1.0, 1.0,
2, 2, 2, 2)
# --- last update
label = JLabel("Last Update:")
self.constrain(label, REL, REL, REL, REM,
HORIZ, NW, 1.0, 1.0,
2, 2, 2, 2)
self.field_lastupdate = JTextField()
self.field_lastupdate.setEditable(0)
self.constrain(self.field_lastupdate, REL, REL, REM, REM,
HORIZ, NW, 1.0, 1.0,
2, 2, 2, 2)
def setChannel(self, channel):
self.channel = channel
self.field_title.setText(channel.getTitle())
self.field_descr.setText(channel.getDescription())
self.field_location.setText(channel.getLocation().toString())
self.field_lastupdate.setText(channel.getSubscription().getLastUpdated().toString())
def refresh(self):
self.setChannel(self.channel)
def constrain(self, component,
grid_x, grid_y, grid_width, grid_height,
fill, anchor, weight_x, weight_y,
top, left, bottom, right):
container = self
c = self.gbc
c.gridx = grid_x
c.gridy = grid_y
c.gridwidth = grid_width
c.gridheight = grid_height
c.fill = fill
c.anchor = anchor
c.weightx = weight_x
c.weighty = weight_y
if (top + bottom + left + right > 0):
c.insets = Insets(top, left, bottom, right)
container.getLayout().setConstraints(component, c)
container.add(component)
class SeniorDesign(JFrame):
startTime =0
endTime =0
global timeTextField
global end
def __init__(self):
self.timeTextField = JTextField("00:00")
self.end = True
pass
def drawChart(self):
data = [(10, 20, 30), (20, 65, 33),
(30, 55, 30), (40, 45, 51),
(50, 25, 27), (60, 75, 30)]
ar = area.T(size = (150,120),
y_grid_interval=10,
x_axis=axis.X(label="X label", label_offset=(0,-7)),
y_axis=axis.Y(label="Y label"),
legend = legend.T(), y_range = (0, None))
ar.add_plot(bar_plot.T(label="foo", data=data),
line_plot.T(label="bar", data=data, ycol=2))
ar.draw()
def createChart(self):
ds = XYDataset()
data = { {0.1, 0.2, 0.3}, {1, 2, 3} }
ds.addSeries("series1", data)
chart = ChartFactory.createXYLineChart("DemoChart", "x", "y", PlotOrientation.VERTICAL, ds, True, True, False)
chartPanel= ChartPanel()
return chartPanel
def createMenuBar(self):
#JMenuBar menuBar;
#JMenu soccerHub, subscriptions,skin,suggestions,help;
menuBar = JMenuBar();
#SoccerHub menu
seniorDesign = JMenu("SeniorDesign");
#seniorDesign.setMnemonic(KeyEvent.VK_0);
menuBar.add(seniorDesign);
#subscription menu
statistics = JMenu("Statistics");
#subscriptions.setMnemonic(KeyEvent.VK_1);
menuBar.add(statistics);
return menuBar;
def mytimer(self,timeTextField):
timer = Timer()
while(True):
timeTextField.setText(timer.getTime())
def getTimeElapsed(self,elapsed):
global startTime
millis = int(round(time.time()*1000))
#elapsedTime = millis - startTime;
elapsedTime = elapsed
#elapsedTime = elapsedTime / 1000;
seconds = str((int)((elapsedTime/1000) % 60));
minutes = str((int)((elapsedTime/(1000*60)) % 60));
hours = str((int)((elapsedTime/(1000*60*60)) % 24));
if (len(seconds) < 2):
seconds = "0" + seconds;
if (len(minutes) < 2):
minutes = "0" + minutes;
if (len(hours) < 2):
hours = "0" + hours;
return hours+":"+minutes+":"+seconds;
def startTimer(self,event):
global startTime
#startTime = time.time()
startTime = int(Calendar.getInstance().getTimeInMillis())
self.updateTextField("Running")
timer = Timer()
def stopTimer(self,event):
global endTime
endTime = int(Calendar.getInstance().getTimeInMillis())
self.updateTextField(self.getTimeElapsed(endTime-startTime))
def timerListener(self,textfield):
time = self.getTimeElapsed()
textfield.setText(time)
def printTime(self):
print "Current time"+ self.getTimeElapsed(time.time()*1000)
def updateTextField(self,text):
self.timeTextField.setText(str(text))
self.repaint()
def updateText(self,textField,startTime):
count=1
while(count < 10000):
#print "start Time" + str(self.getTimeElapsed(startTime))
print "start Time: " + str(int(startTime))
#print "end Time" + str(time.time()-startTime)
elapsed = Calendar.getInstance().getTimeInMillis() - startTime
#print "elapsed Time" + self.getTimeElapsed(elapsed)
timer =Timer(1000,self.printTime,())
timer.start()
textField.setText( 'Elapsed: %.2f seconds' % ( float( elapsed ) / 1000.0 ) );
count =count+1
#textField.setText(self.getTimeElapsed(elapsed))
def addComponentsToPane(self):
global stopWatch
# global textF
pane = JPanel()
layout = GridLayout(0,2)
pane.setLayout(layout)
distanceLabel = JLabel("Distance")
pane.add(distanceLabel)
distanceTextField = JTextField("Distance")
pane.add(distanceTextField)
timeLabel = JLabel("Time")
pane.add(timeLabel)
elapsed = Calendar.getInstance().getTimeInMillis()
#timeTextField = JTextField("00:00")
pane.add(self.timeTextField)
colorLabel = JLabel("color")
pane.add(colorLabel)
colors = ["Black", "Blue", "Red"]
colorCombo = JComboBox(colors)
pane.add(colorCombo)
startButton = JButton("Start", actionPerformed =self.startTimer)
stopButton = JButton("Stop", actionPerformed = self.stopTimer)
leftpanel = self.createChart()
pane.add(startButton)
pane.add(stopButton)
self.add(pane)
self.add(leftpanel,BorderLayout.EAST)
def createAndShowGUI(self):
frame= SeniorDesign()
frame.setJMenuBar(self.createMenuBar())
frame.addComponentsToPane()
frame.pack()
frame.setSize(500,500)
frame.setVisible(True);
def main(self):
self.createAndShowGUI()
class CuckooSettingsWithUISettingsPanel(IngestModuleIngestJobSettingsPanel):
# Note, we can't use a self.settings instance variable.
# Rather, self.local_settings is used.
# https://wiki.python.org/jython/UserGuide#javabean-properties
# Jython Introspector generates a property - 'settings' on the basis
# of getSettings() defined in this class. Since only getter function
# is present, it creates a read-only 'settings' property. This auto-
# generated read-only property overshadows the instance-variable -
# 'settings'
# We get passed in a previous version of the settings so that we can
# prepopulate the UI
# TODO: Update this for your UI
def __init__(self, settings):
self.local_settings = settings
self.tag_list = []
self.initComponents()
self.customizeComponents()
self.path_to_cuckoo_exe = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cuckoo_api.exe")
# Check the checkboxs to see what actions need to be taken
def checkBoxEvent(self, event):
if self.Submit_File_CB.isSelected():
self.local_settings.setSetting('Submit_File', 'true')
self.local_settings.setSetting('Submit_URL', 'false')
else:
self.local_settings.setSetting('Submit_File', 'false')
def onchange_lb(self, event):
self.local_settings.cleartag_list()
list_selected = self.List_Box_LB.getSelectedValuesList()
self.local_settings.setSetting('tag_list', str(list_selected))
def find_tags(self):
sql_statement = "SELECT distinct(display_name) u_tag_name FROM content_tags INNER JOIN tag_names ON " + \
" content_tags.tag_name_id = tag_names.tag_name_id;"
skCase = Case.getCurrentCase().getSleuthkitCase()
dbquery = skCase.executeQuery(sql_statement)
resultSet = dbquery.getResultSet()
while resultSet.next():
self.tag_list.append(resultSet.getString("u_tag_name"))
dbquery.close()
# Check to see if the Cuckoo server is available and you can talk to it
def Check_Server(self, e):
pipe = Popen([self.path_to_cuckoo_exe, self.Protocol_TF.getText(),self.IP_Address_TF.getText(), self.Port_Number_TF.getText(), "cuckoo_status" ], stdout=PIPE, stderr=PIPE)
out_text = pipe.communicate()[0]
self.Error_Message.setText("Cuckoo Status is " + out_text)
#self.log(Level.INFO, "Cuckoo Status is ==> " + out_text)
def setIPAddress(self, event):
self.local_settings.setSetting('IP_Address', self.IP_Address_TF.getText())
def setProtocol(self, event):
self.local_settings.setSetting('Protocol', self.Protocol_TF.getText())
def setPortNumber(self, event):
self.local_settings.setSetting('Port_Number', self.Port_Number_TF.getText())
# Create the initial data fields/layout in the UI
def initComponents(self):
self.panel0 = JPanel()
self.rbgPanel0 = ButtonGroup()
self.gbPanel0 = GridBagLayout()
self.gbcPanel0 = GridBagConstraints()
self.panel0.setLayout( self.gbPanel0 )
self.Label_1 = JLabel("Protocol:")
self.Label_1.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 1
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_1, self.gbcPanel0 )
self.panel0.add( self.Label_1 )
self.Protocol_TF = JTextField(20, focusLost=self.setProtocol)
self.Protocol_TF.setEnabled(True)
self.gbcPanel0.gridx = 4
self.gbcPanel0.gridy = 1
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Protocol_TF, self.gbcPanel0 )
self.panel0.add( self.Protocol_TF )
self.Blank_1 = JLabel( " ")
self.Blank_1.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 3
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_1, self.gbcPanel0 )
self.panel0.add( self.Blank_1 )
self.Label_2 = JLabel("Cuckoo IP Address")
self.Label_2.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 5
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_2, self.gbcPanel0 )
self.panel0.add( self.Label_2 )
self.IP_Address_TF = JTextField(20, focusLost=self.setIPAddress)
self.IP_Address_TF.setEnabled(True)
self.gbcPanel0.gridx = 4
self.gbcPanel0.gridy = 5
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.IP_Address_TF, self.gbcPanel0 )
self.panel0.add( self.IP_Address_TF )
self.Blank_2 = JLabel( " ")
self.Blank_2.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 7
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_2, self.gbcPanel0 )
self.panel0.add( self.Blank_2 )
self.Label_3 = JLabel("Port Number")
self.Label_3.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 9
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_3, self.gbcPanel0 )
self.panel0.add( self.Label_3 )
self.Port_Number_TF = JTextField(20, focusLost=self.setPortNumber)
self.Port_Number_TF.setEnabled(True)
self.gbcPanel0.gridx = 4
self.gbcPanel0.gridy = 9
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Port_Number_TF, self.gbcPanel0 )
self.panel0.add( self.Port_Number_TF )
self.Blank_3 = JLabel( " ")
self.Blank_3.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 11
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_3, self.gbcPanel0 )
self.panel0.add( self.Blank_3 )
self.Blank_5 = JLabel( "Tag to Choose: ")
self.Blank_5.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 13
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_5, self.gbcPanel0 )
self.panel0.add( self.Blank_5 )
self.find_tags()
self.List_Box_LB = JList( self.tag_list, valueChanged=self.onchange_lb)
self.List_Box_LB.setVisibleRowCount( 3 )
self.scpList_Box_LB = JScrollPane( self.List_Box_LB )
self.gbcPanel0.gridx = 4
self.gbcPanel0.gridy = 13
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 1
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.scpList_Box_LB, self.gbcPanel0 )
self.panel0.add( self.scpList_Box_LB )
self.Blank_6 = JLabel( " ")
self.Blank_6.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 15
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_6, self.gbcPanel0 )
self.panel0.add( self.Blank_6 )
self.Submit_File_CB = JCheckBox("Submit a File", actionPerformed=self.checkBoxEvent)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 17
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Submit_File_CB, self.gbcPanel0 )
self.panel0.add( self.Submit_File_CB )
# self.Submit_URL_CB = JCheckBox("Submit a URL", actionPerformed=self.checkBoxEvent)
# self.gbcPanel0.gridx = 2
# self.gbcPanel0.gridy = 23
# self.gbcPanel0.gridwidth = 1
# self.gbcPanel0.gridheight = 1
# self.gbcPanel0.fill = GridBagConstraints.BOTH
# self.gbcPanel0.weightx = 1
# self.gbcPanel0.weighty = 0
# self.gbcPanel0.anchor = GridBagConstraints.NORTH
# self.gbPanel0.setConstraints( self.Submit_URL_CB, self.gbcPanel0 )
# self.panel0.add( self.Submit_URL_CB )
self.Check_Server_Status_BTN = JButton( "Check Server Status", actionPerformed=self.Check_Server)
self.Check_Server_Status_BTN.setEnabled(True)
self.rbgPanel0.add( self.Check_Server_Status_BTN )
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 19
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Check_Server_Status_BTN, self.gbcPanel0 )
self.panel0.add( self.Check_Server_Status_BTN )
self.Error_Message = JLabel( "")
self.Error_Message.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 21
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Error_Message, self.gbcPanel0 )
self.panel0.add( self.Error_Message )
self.add(self.panel0)
# Custom load any data field and initialize the values
def customizeComponents(self):
#self.Exclude_File_Sources_CB.setSelected(self.local_settings.getExclude_File_Sources())
#self.Run_Cuckoo_CB.setSelected(self.local_settings.getSetting('Submit_File') == 'true')
#self.Import_Cuckoo_CB.setSelected(self.local_settings.getImport_Cuckoo())
self.Port_Number_TF.setText(self.local_settings.getSetting('Port_Number'))
self.IP_Address_TF.setText(self.local_settings.getSetting('IP_Address'))
self.Protocol_TF.setText(self.local_settings.getSetting('Protocol'))
# Return the settings used
def getSettings(self):
return self.local_settings
class BobGui(JFrame):
def __init__(self):
super(BobGui, self).__init__('BobPy')
# IJ.log('okay?')
# print('okay??')
self.setLayout(BorderLayout())
self.main_panel = JPanel()
# self.main_panel.setLayout(MigLayout('insets 1 10 1 1'))
self.main_panel.setLayout(MigLayout())
dir_panel = JPanel()
dir_panel.setLayout(BoxLayout(dir_panel, BoxLayout.X_AXIS))
dir_label = JLabel('Experiment Folder:')
dir_panel.add(dir_label)
self.dir_text_field = JTextField(10)
self.dir_text_field.addActionListener(
ActionListenerFactory(self, self.text_field_al))
dir_panel.add(self.dir_text_field)
dir_button = JButton('open')
dir_button.addActionListener(
ActionListenerFactory(self, self.choose_dir_al))
dir_panel.add(dir_button)
self.main_panel.add(dir_panel, 'wrap, growx, spanx, pushx')
add_key_args(self.main_panel, 'close_w',
ActionListenerFactory(self, self.close_al), KeyEvent.VK_W,
Toolkit.getDefaultToolkit().getMenuShortcutKeyMask())
self.add(self.main_panel, BorderLayout.CENTER)
self.setPreferredSize(Dimension(650, 600))
self.pack()
self.setLocationRelativeTo(None)
self.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
self.setVisible(True)
def show_exper_info(self):
chf_panel = self.make_chf_panel()
hseg_tree_panel = self.make_hseg_tree_panel()
self.split_pane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT)
self.split_pane.setOneTouchExpandable(True)
self.split_pane.setContinuousLayout(True)
self.split_pane.setResizeWeight(0.5)
self.split_pane.add(chf_panel)
self.split_pane.add(hseg_tree_panel)
self.main_panel.add(self.split_pane, 'grow, wrap')
# self.log_text = JTextArea()
self.main_panel.add(self.log_text, 'grow, wrap')
self.log_text.setLineWrap(True)
self.log_text.setWrapStyleWord(True)
self.revalidate()
def make_chf_panel(self):
""" chf --> common hseg files """
chf_panel = JPanel()
chf_panel.setLayout(MigLayout('insets 0'))
chf_files_label = JLabel('Hemisegment cells')
chf_files_text = JTextArea(
BobGui.archetype_to_str(
self.exper.hseg_cell_files_cab().archetype))
chf_panel.add(chf_files_label, 'growx, wrap')
chf_panel.add(chf_files_text, 'grow, wrap')
chf_files_label = JLabel('Hemisegment binary image files')
chf_files_text = JTextArea(
BobGui.archetype_to_str(self.exper.hseg_bin_files_cab().archetype))
chf_panel.add(chf_files_label, 'growx, wrap')
chf_panel.add(chf_files_text, 'grow, wrap')
chf_files_label = JLabel('Intensity Image Files')
# chf_files_text = JTextArea(BobGui.archetype_to_str(self.exper.hseg_intens_im_files_cab().archetype))
# print(self.exper.hseg_intens_im_files_cab().archetype)
# chf_panel.add(chf_files_label, 'growx, wrap')
# chf_panel.add(chf_files_text, 'grow, wrap')
self.intens_im_boxes = []
intens_im_panel = JPanel()
intens_im_panel.setLayout(MigLayout('insets 0'))
for poss_im_file in self.exper.hseg_intens_im_files_cab().archetype:
self.intens_im_boxes.append(JCheckBox(poss_im_file))
intens_im_panel.add(self.intens_im_boxes[-1], 'wrap')
chf_panel.add(chf_files_label, 'growx, wrap')
chf_panel.add(intens_im_panel, 'grow, wrap')
mdf_create_button = JButton(
'Create meta_data file from default outline')
# mdf_create_button = JButton('<html>Create meta_data file<br>from default outline</html>')
mdf_create_button.addActionListener(
ActionListenerFactory(self, self.mdf_create_al))
mdf_open_button = JButton('Open existing meta_data file')
mdf_open_button.addActionListener(
ActionListenerFactory(self, self.mdf_open_al))
# meta_data_file_buttton = JButton('Open/Create meta_data file')
# meta_data_file_buttton.addActionListener(ActionListenerFactory(self, self.meta_data_al))
# chf_panel.add(meta_data_file_buttton)
chf_panel.add(mdf_create_button, 'wrap')
chf_panel.add(mdf_open_button, 'wrap')
chf_scroll_pane = JScrollPane()
chf_scroll_pane.getViewport().setView(chf_panel)
return chf_scroll_pane
@staticmethod
def archetype_to_str(archetype):
at_str = ''
for val in archetype:
at_str += str(val) + '\n'
return at_str
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 log(self, text):
self.log_text.append(str(text) + '\n')
def text_field_al(self, e):
# self.dir_path =
self.got_exper(self.dir_text_field.getText())
def choose_dir_al(self, e):
dc = DirectoryChooser('Choose a bob_py experiment folder')
# self.dir_path = dc.getDirectory()
# self.dir_text_field.setText(self.dir_path)
# self.dir_text_field.setText('blerg')
# IJ.log('blerg')
# print('boop')
self.got_exper(dc.getDirectory())
def close_al(self, e):
self.dispatchEvent(WindowEvent(self, WindowEvent.WINDOW_CLOSING))
def run_al(self, e):
# dt = br.dtic('Processed experiment {}'.format(self.exper.name))
t = br.tic()
self.exper.make_data()
self.exper.output_cell_cols_def()
self.exper.output_nuc_cols_def()
self.exper.output_new_hdings()
self.exper.log('Processed experiment {} in {:.3f} seconds'.format(
self.exper.name, br.toc(t)))
# br.dtoc(dt)
def rerun_al(self, e):
# dt = br.dtic('Processed experiment {}'.format(self.exper.name))
# t = br.tic()
self.exper = None
self.got_exper(self.dir_path)
self.run_al(None)
# self.exper =
# self.exper.make_data()
# self.exper.output_cell_cols_def()
# self.exper.output_nuc_cols_def()
# self.exper.output_new_hdings()
#
# self.exper.log('Created and processed experiment {} in {:.3f} seconds'.format(self.exper.name, br.toc(t)))
# br.dtoc(dt)
# def meta_data_al(self, e) :
# meta_data_path = self.exper.meta_data_path()
# if not os.path.exists(meta_data_path) :
# txt = make_meta_data_str(self.exper)
# with open(meta_data_path, 'w') as f :
# f.write(txt)
#
# IJ.open(meta_data_path)
def mdf_create_al(self, e):
meta_data_path = self.exper.meta_data_path()
# if not os.path.exists(meta_data_path) :
intens_im_list = []
for check_box in self.intens_im_boxes:
if check_box.isSelected():
intens_im_list.append(check_box.getLabel())
txt = make_meta_data_str2(self.exper, intens_im_list)
with open(meta_data_path, 'w') as f:
f.write(txt)
# IJ.open(meta_data_path)
def mdf_open_al(self, e):
meta_data_path = self.exper.meta_data_path()
IJ.open(meta_data_path)
def got_exper(self, dir_path):
# IJ.log('exper')
self.dir_path = dir_path
self.dir_text_field.setText(self.dir_path)
self.log_text = JTextArea()
self.exper = bob_py.Exper(dir_path, gui=self)
self.show_exper_info()
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))
def __init__(self, imgData):
n = imgData.size()
win = JFrame("Point Marker Panel")
win.setPreferredSize(Dimension(350, 590))
win.setSize(win.getPreferredSize())
pan = JPanel()
pan.setLayout(BoxLayout(pan, BoxLayout.Y_AXIS))
win.getContentPane().add(pan)
progressPanel = JPanel()
progressPanel.setLayout(BoxLayout(progressPanel, BoxLayout.Y_AXIS))
positionBar = JProgressBar()
positionBar.setMinimum(0)
positionBar.setMaximum(n)
positionBar.setStringPainted(True)
progressPanel.add(Box.createGlue())
progressPanel.add(positionBar)
progressBar = JProgressBar()
progressBar.setMinimum(0)
progressBar.setMaximum(n)
progressBar.setStringPainted(True)
progressPanel.add(progressBar)
progressPanel.setBorder(BorderFactory.createEmptyBorder(0,10,0,10))
pan.add(progressPanel)
pan.add(Box.createRigidArea(Dimension(5,5)))
savePanel = JPanel()
savePanel.setLayout(BoxLayout(savePanel, BoxLayout.Y_AXIS))
saveMessageLabel = JLabel("<html><u>Save Often</u></html>")
savePanel.add(saveMessageLabel)
savePanel.setAlignmentX(Component.CENTER_ALIGNMENT)
savePanel.setBorder(BorderFactory.createEmptyBorder(0,10,0,10))
pan.add(savePanel)
# pan.add(saveMessageLabel)
pan.add(Box.createRigidArea(Dimension(5,5)))
calPanel = JPanel()
calPanel.setLayout(BoxLayout(calPanel, BoxLayout.Y_AXIS))
calPanelIn = JPanel()
calPanelIn.setLayout(BoxLayout(calPanelIn, BoxLayout.X_AXIS))
pixelSizeText = JTextField(12)
pixelSizeText.setHorizontalAlignment(JTextField.RIGHT)
# pixelSizeText.setMaximumSize(pixelSizeText.getPreferredSize())
unitText = JTextField(10)
# unitText.setMaximumSize(unitText.getPreferredSize())
pixelSizeText.setText("Enter Pixel Size Here")
calPanelIn.add(pixelSizeText)
unitText.setText("Unit")
calPanelIn.add(unitText)
calPanelIn.setAlignmentX(Component.CENTER_ALIGNMENT)
calPanelIn.setBorder(BorderFactory.createTitledBorder("Custom Calibration"))
calPanel.add(calPanelIn)
calPanelIn.setAlignmentX(Component.CENTER_ALIGNMENT)
calPanel.setBorder(BorderFactory.createEmptyBorder(0,10,0,10))
pan.add(calPanel)
pan.add(Box.createRigidArea(Dimension(5,5)))
helpPanel = JPanel()
helpPanel.setLayout(BoxLayout(helpPanel, BoxLayout.Y_AXIS))
helpLable = JLabel("<html><ul>\
<li>Focus on Image Window</li>\
<li>Select multi-point Tool</li>\
<li>Click to Draw Points</li>\
<li>Drag to Move Points</li>\
<li>\"Alt\" + Click to Erase Points</li>\
<li>Optional: Customize Calibration Above\
and Refresh Images\
(won't be written to files)</li>\
</html>")
helpLable.setBorder(BorderFactory.createTitledBorder("Usage"))
keyTagOpen = "<span style=\"background-color: #FFFFFF\"><b><kbd>"
keyTagClose = "</kbd></b></span>"
keyLable = JLabel("<html><ul>\
<li>Next Image --- " + keyTagOpen + "<" + \
keyTagClose + "</li>\
<li>Previous Image --- " + keyTagOpen + ">" + \
keyTagClose + "</li>\
<li>Save --- " + keyTagOpen + "`" + keyTagClose + \
" (upper-left to TAB key)</li>\
<li>Next Unmarked Image --- " + keyTagOpen + \
"TAB" + keyTagClose + "</li></ul>\
</html>")
keyLable.setBorder(BorderFactory.createTitledBorder("Keyboard Shortcuts"))
helpPanel.add(helpLable)
helpPanel.add(keyLable)
helpPanel.setAlignmentX(Component.CENTER_ALIGNMENT)
helpPanel.setBorder(BorderFactory.createEmptyBorder(0,10,0,10))
pan.add(helpPanel)
# pan.add(Box.createRigidArea(Dimension(0, 10)))
infoPanel = JPanel()
infoPanel.setLayout(BoxLayout(infoPanel, BoxLayout.Y_AXIS))
infoLabel = JLabel()
infoLabel.setBorder(BorderFactory.createTitledBorder("Project Info"))
infoPanel.add(infoLabel)
infoPanel.setAlignmentX(Component.CENTER_ALIGNMENT)
infoPanel.setBorder(BorderFactory.createEmptyBorder(0,10,0,10))
pan.add(infoPanel)
win.setVisible(True)
self.imgData = imgData
self.win = win
# self.progressPanel = progressPanel
self.positionBar = positionBar
self.progressBar = progressBar
self.saveMessageLabel = saveMessageLabel
self.infoLabel = infoLabel
self.pixelSizeText = pixelSizeText
self.unitText = unitText
self.update()
text = feld.getText()
name = feld2.getText() + ".csv"
with open(name,"w") as f:
f.write(text)
print(name + " gespeichert")
return(text)
button = JButton('Lektion speichern!', actionPerformed=change_text,size=(10,20))
button.setBounds(20,40,20,40);
pnl = JPanel()
pnl.setLayout(BoxLayout(pnl, BoxLayout.Y_AXIS))
feld = JTextArea()
feld.editable = True
feld.setText("Deutsch,Englisch\n")
feld2 = JTextField()
feld2.setText("Ersetzen durch Namen der Lektion")
pnl.add(feld2)
pnl.add(feld)
pnl.add(button)
frame.add(pnl)
frame.setVisible(True)
class Main(Client):
def __init__(self):
pass
def stateChanged(self, cs):
print "new state: " + str(cs)
def sessionStarted(self):
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)
class BurpExtender(IBurpExtender, ITab, IHttpListener,
IMessageEditorController, AbstractTableModel,
ActionListener, DocumentListener):
#
# implement IBurpExtender
#
def registerExtenderCallbacks(self, callbacks):
# keep a reference to our callbacks object
self._callbacks = callbacks
# obtain an extension helpers object
self._helpers = callbacks.getHelpers()
# set our extension name
callbacks.setExtensionName("Response Clusterer")
# create the log and a lock on which to synchronize when adding log entries
self._log = ArrayList()
self._lock = Lock()
# main split pane
self._main_jtabedpane = JTabbedPane()
# The split pane with the log and request/respponse details
self._splitpane = JSplitPane(JSplitPane.VERTICAL_SPLIT)
# table of log entries
logTable = Table(self)
scrollPane = JScrollPane(logTable)
self._splitpane.setLeftComponent(scrollPane)
# List of log entries
self._log_entries = []
# tabs with request/response viewers
tabs = JTabbedPane()
self._requestViewer = callbacks.createMessageEditor(self, False)
self._responseViewer = callbacks.createMessageEditor(self, False)
tabs.addTab("Request", self._requestViewer.getComponent())
tabs.addTab("Response", self._responseViewer.getComponent())
self._splitpane.setRightComponent(tabs)
#Setup the options
self._optionsJPanel = JPanel()
gridBagLayout = GridBagLayout()
gbc = GridBagConstraints()
self._optionsJPanel.setLayout(gridBagLayout)
self.max_clusters = 500
self.JLabel_max_clusters = JLabel("Maximum amount of clusters: ")
gbc.gridy = 0
gbc.gridx = 0
self._optionsJPanel.add(self.JLabel_max_clusters, gbc)
self.JTextField_max_clusters = JTextField(str(self.max_clusters), 5)
self.JTextField_max_clusters.getDocument().addDocumentListener(self)
gbc.gridx = 1
self._optionsJPanel.add(self.JTextField_max_clusters, gbc)
callbacks.customizeUiComponent(self.JLabel_max_clusters)
callbacks.customizeUiComponent(self.JTextField_max_clusters)
self.similarity = 0.95
self.JLabel_similarity = JLabel("Similarity (between 0 and 1)")
gbc.gridy = 1
gbc.gridx = 0
self._optionsJPanel.add(self.JLabel_similarity, gbc)
self.JTextField_similarity = JTextField(str(self.similarity), 5)
self.JTextField_similarity.getDocument().addDocumentListener(self)
gbc.gridx = 1
self._optionsJPanel.add(self.JTextField_similarity, gbc)
callbacks.customizeUiComponent(self.JLabel_similarity)
callbacks.customizeUiComponent(self.JTextField_similarity)
self.use_quick_similar = False
self.JLabel_use_quick_similar = JLabel(
"Use set intersection of space splitted tokens for similarity (default: optimized difflib.SequenceMatcher.quick_ratio)"
)
gbc.gridy = 2
gbc.gridx = 0
self._optionsJPanel.add(self.JLabel_use_quick_similar, gbc)
self.JCheckBox_use_quick_similar = JCheckBox("")
self.JCheckBox_use_quick_similar.addActionListener(self)
gbc.gridx = 1
self._optionsJPanel.add(self.JCheckBox_use_quick_similar, gbc)
callbacks.customizeUiComponent(self.JCheckBox_use_quick_similar)
self.response_max_size = 10 * 1024 #10kb
self.JLabel_response_max_size = JLabel("Response max size (bytes)")
gbc.gridy = 3
gbc.gridx = 0
self._optionsJPanel.add(self.JLabel_response_max_size, gbc)
self.JTextField_response_max_size = JTextField(
str(self.response_max_size), 5)
self.JTextField_response_max_size.getDocument().addDocumentListener(
self)
gbc.gridx = 1
self._optionsJPanel.add(self.JTextField_response_max_size, gbc)
callbacks.customizeUiComponent(self.JLabel_response_max_size)
callbacks.customizeUiComponent(self.JTextField_response_max_size)
self.uninteresting_mime_types = ('JPEG', 'CSS', 'GIF', 'script', 'GIF',
'PNG', 'image')
self.uninteresting_status_codes = ()
self.uninteresting_url_file_extensions = ('js', 'css', 'zip', 'war',
'jar', 'doc', 'docx', 'xls',
'xlsx', 'pdf', 'exe', 'dll',
'png', 'jpeg', 'jpg', 'bmp',
'tif', 'tiff', 'gif', 'webp',
'm3u', 'mp4', 'm4a', 'ogg',
'aac', 'flac', 'mp3', 'wav',
'avi', 'mov', 'mpeg', 'wmv',
'swf', 'woff', 'woff2')
about = "<html>"
about += "Author: floyd, @floyd_ch, http://www.floyd.ch<br>"
about += "modzero AG, http://www.modzero.ch<br>"
about += "<br>"
about += "<h3>Getting an overview of the tested website</h3>"
about += "<p style=\"width:500px\">"
about += "This plugin clusters all response bodies by similarity and shows a summary, one request/response per cluster. "
about += 'Adjust similarity in the options if you get too few or too many entries in the "One member of each cluster" '
about += "tab. The plugin will allow a tester to get an overview of the tested website's responses from all tools (scanner, proxy, etc.). "
about += "As similarity comparison "
about += "can use a lot of ressources, only small, in-scope responses that have interesting response codes, "
about += "file extensions and mime types are processed. "
about += "</p>"
about += "</html>"
self.JLabel_about = JLabel(about)
self.JLabel_about.setLayout(GridBagLayout())
self._aboutJPanel = JScrollPane(self.JLabel_about)
# customize our UI components
callbacks.customizeUiComponent(self._splitpane)
callbacks.customizeUiComponent(logTable)
callbacks.customizeUiComponent(scrollPane)
callbacks.customizeUiComponent(tabs)
# add the splitpane and options to the main jtabedpane
self._main_jtabedpane.addTab("One member of each cluster", None,
self._splitpane, None)
self._main_jtabedpane.addTab("Options", None, self._optionsJPanel,
None)
self._main_jtabedpane.addTab("About & README", None, self._aboutJPanel,
None)
# clusters will grow up to self.max_clusters response bodies...
self._clusters = set()
self.Similarity = Similarity()
# Now load the already stored
with self._lock:
log_entries_from_storage = self.load_project_setting("log_entries")
if log_entries_from_storage:
for toolFlag, req, resp, url in log_entries_from_storage:
try:
self.add_new_log_entry(toolFlag, req, resp, url)
except Exception as e:
print "Exception when deserializing a stored log entry", toolFlag, url
print e
# Important: Do this at the very end (otherwise we could run into troubles locking up entire threads)
# add the custom tab to Burp's UI
callbacks.addSuiteTab(self)
# register ourselves as an HTTP listener
callbacks.registerHttpListener(self)
#
# implement what happens when options are changed
#
def changedUpdate(self, document):
pass
def removeUpdate(self, document):
self.actionPerformed(None)
def insertUpdate(self, document):
self.actionPerformed(None)
def actionPerformed(self, actionEvent):
self.use_quick_similar = self.JCheckBox_use_quick_similar.isSelected()
try:
self.max_clusters = int(self.JTextField_max_clusters.getText())
except:
self.JTextField_max_clusters.setText("200")
try:
self.similarity = float(self.JTextField_similarity.getText())
if self.similarity > 1.0 or self.similarity < 0.0:
self.JTextField_similarity.setText("0.9")
except:
self.JTextField_similarity.setText("0.9")
try:
self.response_max_size = float(
self.JTextField_response_max_size.getText())
if self.response_max_size < 0.0:
self.JTextField_response_max_size.setText(str(10 * 1024))
except:
self.JTextField_response_max_size.setText(str(10 * 1024))
print self.JCheckBox_use_quick_similar.isSelected(
), self.JTextField_max_clusters.getText(
), self.JTextField_similarity.getText(
), self.JTextField_response_max_size.getText()
#
# implement ITab
#
def getTabCaption(self):
return "Response Clusterer"
def getUiComponent(self):
return self._main_jtabedpane
#
# implement IHttpListener
#
def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
if not messageIsRequest:
if len(self._clusters) >= self.max_clusters:
return
resp = messageInfo.getResponse()
if len(resp) >= self.response_max_size:
print "Message was too long"
return
iResponseInfo = self._helpers.analyzeResponse(resp)
mime_type = iResponseInfo.getStatedMimeType()
if mime_type in self.uninteresting_mime_types:
print "Mime type", mime_type, "is ignored"
return
if iResponseInfo.getStatusCode(
) in self.uninteresting_status_codes:
print "Status code", iResponseInfo.getStatusCode(
), "is ignored"
return
req = messageInfo.getRequest()
iRequestInfo = self._helpers.analyzeRequest(messageInfo)
if not iRequestInfo.getUrl():
print "iRequestInfo.getUrl() returned None, so bailing out of analyzing this request"
return
if '.' in iRequestInfo.getUrl().getFile() and iRequestInfo.getUrl(
).getFile().split(
'.')[-1] in self.uninteresting_url_file_extensions:
print iRequestInfo.getUrl().getFile().split(
'.')[-1], "is an ignored file extension"
return
if not self._callbacks.isInScope(iRequestInfo.getUrl()):
print iRequestInfo.getUrl(), "is not in scope"
return
body = resp[iResponseInfo.getBodyOffset():]
with self._lock:
similarity_func = self.Similarity.similar
if self.use_quick_similar:
similarity_func = self.Similarity.quick_similar
start_time = time.time()
for response_code, item in self._clusters:
if not response_code == iResponseInfo.getStatusCode():
#Different response codes -> different clusters
continue
if similarity_func(str(body), str(item), self.similarity):
return #break
else: #when no break/return occures in the for loop
self.add_new_log_entry(toolFlag, req, resp,
iRequestInfo.getUrl().toString())
self.save_project_setting("log_entries", self._log_entries)
taken_time = time.time() - start_time
if taken_time > 0.5:
print "Plugin took", taken_time, "seconds to process request... body length:", len(
body), "current cluster length:", len(self._clusters)
print "URL:", str(iRequestInfo.getUrl()),
def add_new_log_entry(self, toolFlag, request, response, service_url):
self._log_entries.append((toolFlag, request, response, service_url))
iResponseInfo = self._helpers.analyzeResponse(response)
body = response[iResponseInfo.getBodyOffset():]
self._clusters.add((iResponseInfo.getStatusCode(), str(body)))
row = self._log.size()
service = CustomHttpService(service_url)
r = CustomRequestResponse(None, None, service, request, response)
iRequestInfo = self._helpers.analyzeRequest(r)
self._log.add(
LogEntry(toolFlag, self._callbacks.saveBuffersToTempFiles(r),
iRequestInfo.getUrl()))
self.fireTableRowsInserted(row, row)
#
# extend AbstractTableModel
#
def getRowCount(self):
try:
return self._log.size()
except:
return 0
def getColumnCount(self):
return 2
def getColumnName(self, columnIndex):
if columnIndex == 0:
return "Tool"
if columnIndex == 1:
return "URL"
return ""
def getValueAt(self, rowIndex, columnIndex):
logEntry = self._log.get(rowIndex)
if columnIndex == 0:
return self._callbacks.getToolName(logEntry._tool)
if columnIndex == 1:
return logEntry._url.toString()
return ""
#
# implement IMessageEditorController
# this allows our request/response viewers to obtain details about the messages being displayed
#
def getHttpService(self):
return self._currentlyDisplayedItem.getHttpService()
def getRequest(self):
return self._currentlyDisplayedItem.getRequest()
def getResponse(self):
return self._currentlyDisplayedItem.getResponse()
def save_project_setting(self, name, value):
value = pickle.dumps(value).encode("base64")
request = "GET /"+name+" HTTP/1.0\r\n\r\n" \
"You can ignore this item in the site map. It was created by the ResponseClusterer extension. The \n" \
"reason is that the Burp API is missing a certain functionality to save settings. \n" \
"TODO Burp API limitation: This is a hackish way to be able to store project-scope settings.\n" \
"We don't want to restore requests/responses of tabs in a totally different Burp project.\n" \
"However, unfortunately there is no saveExtensionProjectSetting in the Burp API :(\n" \
"So we have to abuse the addToSiteMap API to store project-specific things\n" \
"Even when using this hack we currently cannot persist Collaborator interaction checks\n" \
"(IBurpCollaboratorClientContext is not serializable and Threads loose their Python class\n" \
"functionality when unloaded) due to Burp API limitations."
response = None
if value:
response = "HTTP/1.1 200 OK\r\n" + value
rr = CustomRequestResponse(
name, '',
CustomHttpService('http://responseclustererextension.local/'),
request, response)
self._callbacks.addToSiteMap(rr)
def load_project_setting(self, name):
rrs = self._callbacks.getSiteMap(
'http://responseclustererextension.local/' + name)
if rrs:
rr = rrs[0]
if rr.getResponse():
val = "\r\n".join(
FloydsHelpers.jb2ps(rr.getResponse()).split("\r\n")[1:])
return pickle.loads(val.decode("base64"))
else:
return None
else:
return None
class VolatilitySettingsWithUISettingsPanel(IngestModuleIngestJobSettingsPanel):
# Note, we can't use a self.settings instance variable.
# Rather, self.local_settings is used.
# https://wiki.python.org/jython/UserGuide#javabean-properties
# Jython Introspector generates a property - 'settings' on the basis
# of getSettings() defined in this class. Since only getter function
# is present, it creates a read-only 'settings' property. This auto-
# generated read-only property overshadows the instance-variable -
# 'settings'
# We get passed in a previous version of the settings so that we can
# prepopulate the UI
# TODO: Update this for your UI
_logger = Logger.getLogger(VolatilityIngestModuleFactory.moduleName)
def log(self, level, msg):
self._logger.logp(level, self.__class__.__name__, inspect.stack()[1][3], msg)
def __init__(self, settings):
self.local_settings = settings
self.initComponents()
self.customizeComponents()
# Check the checkboxs to see what actions need to be taken
def checkBoxEvent(self, event):
if self.Exclude_File_Sources_CB.isSelected():
self.local_settings.setSetting('Exclude_File_Sources', 'true')
else:
self.local_settings.setSetting('Exclude_File_Sources', 'false')
def get_plugins(self):
head, tail = os.path.split(os.path.abspath(__file__))
settings_db = os.path.join(head, "GUI_Settings.db3")
try:
Class.forName("org.sqlite.JDBC").newInstance()
dbConn = DriverManager.getConnection("jdbc:sqlite:%s" % settings_db)
self.Error_Message.setText("Database opened")
except SQLException as e:
self.Error_Message.setText("Error Opening Settings DB!")
try:
stmt = dbConn.createStatement()
SQL_Statement = "select plugin_name from plugins where volatility_version = '" + self.Version_CB.getSelectedItem() + "';"
resultSet = stmt.executeQuery(SQL_Statement)
plugin_list = []
while resultSet.next():
plugin_list.append(resultSet.getString("plugin_name"))
stmt.close()
dbConn.close()
return plugin_list
except SQLException as e:
self.Error_Message.setText("Error Reading plugins")
stmt.close()
dbConn.close()
return "Error"
def get_profiles(self):
head, tail = os.path.split(os.path.abspath(__file__))
settings_db = os.path.join(head, "GUI_Settings.db3")
try:
Class.forName("org.sqlite.JDBC").newInstance()
dbConn = DriverManager.getConnection("jdbc:sqlite:%s" % settings_db)
self.Error_Message.setText("Database opened")
except SQLException as e:
self.Error_Message.setText("Error Opening Settings DB!")
try:
stmt = dbConn.createStatement()
SQL_Statement = "select profile_name from profiles where volatility_version = '" + self.Version_CB.getSelectedItem() + "';"
resultSet = stmt.executeQuery(SQL_Statement)
profile_list = []
while resultSet.next():
profile_list.append(resultSet.getString("profile_name"))
stmt.close()
dbConn.close()
return profile_list
except SQLException as e:
self.Error_Message.setText("Error Reading plugins")
stmt.close()
dbConn.close()
return "Error"
# When button to find file is clicked then open dialog to find the file and return it.
def Find_Dir(self, e):
chooseFile = JFileChooser()
filter = FileNameExtensionFilter("All", ["*.*"])
chooseFile.addChoosableFileFilter(filter)
#chooseFile.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
ret = chooseFile.showDialog(self.panel0, "Find Volatility Directory")
if ret == JFileChooser.APPROVE_OPTION:
file = chooseFile.getSelectedFile()
Canonical_file = file.getCanonicalPath()
#text = self.readPath(file)
self.local_settings.setSetting('Volatility_Directory', Canonical_file)
self.Program_Executable_TF.setText(Canonical_file)
def keyPressed(self, event):
self.local_settings.setSetting('AdditionalParms', self.Additional_Parms_TF.getText())
#self.Error_Message.setText(self.Additional_Parms_TF.getText())
def onchange_version(self, event):
self.local_settings.setSetting('Version', event.item)
plugin_list = self.get_plugins()
profile_list = self.get_profiles()
self.Profile_CB.removeAllItems()
self.Plugin_LB.clearSelection()
self.Plugin_LB.setListData(plugin_list)
for profile in profile_list:
self.Profile_CB.addItem(profile)
#self.Profile_CB.addItems(profile)
self.panel0.repaint()
def onchange_plugins_lb(self, event):
self.local_settings.setSetting('PluginListBox' , '')
list_selected = self.Plugin_LB.getSelectedValuesList()
self.local_settings.setSetting('PluginListBox', str(list_selected))
def onchange_profile_cb(self, event):
self.local_settings.setSetting('Profile', event.item)
# Create the initial data fields/layout in the UI
def initComponents(self):
self.panel0 = JPanel()
self.rbgPanel0 = ButtonGroup()
self.gbPanel0 = GridBagLayout()
self.gbcPanel0 = GridBagConstraints()
self.panel0.setLayout( self.gbPanel0 )
self.Error_Message = JLabel( "")
self.Error_Message.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 31
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Error_Message, self.gbcPanel0 )
self.panel0.add( self.Error_Message )
self.Label_1 = JLabel("Volatility Executable Directory")
self.Label_1.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 1
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_1, self.gbcPanel0 )
self.panel0.add( self.Label_1 )
self.Program_Executable_TF = JTextField(10)
self.Program_Executable_TF.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 3
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Program_Executable_TF, self.gbcPanel0 )
self.panel0.add( self.Program_Executable_TF )
self.Find_Program_Exec_BTN = JButton( "Find Dir", actionPerformed=self.Find_Dir)
self.Find_Program_Exec_BTN.setEnabled(True)
self.rbgPanel0.add( self.Find_Program_Exec_BTN )
self.gbcPanel0.gridx = 6
self.gbcPanel0.gridy = 3
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Find_Program_Exec_BTN, self.gbcPanel0 )
self.panel0.add( self.Find_Program_Exec_BTN )
self.Blank_1 = JLabel( " ")
self.Blank_1.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 5
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_1, self.gbcPanel0 )
self.panel0.add( self.Blank_1 )
self.Version_Label_1 = JLabel( "Version:")
self.Blank_1.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 11
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Version_Label_1, self.gbcPanel0 )
self.panel0.add( self.Version_Label_1 )
self.Version_List = ("2.5", "2.6")
self.Version_CB = JComboBox( self.Version_List)
self.Version_CB.itemStateChanged = self.onchange_version
self.gbcPanel0.gridx = 6
self.gbcPanel0.gridy = 11
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Version_CB, self.gbcPanel0 )
self.panel0.add( self.Version_CB )
self.Blank_3 = JLabel( " ")
self.Blank_3.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 13
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_3, self.gbcPanel0 )
self.panel0.add( self.Blank_3 )
self.Plugin_Label_1 = JLabel( "Plugins:")
self.Blank_1.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 15
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Plugin_Label_1, self.gbcPanel0 )
self.panel0.add( self.Plugin_Label_1 )
self.Plugin_list = self.get_plugins()
self.Plugin_LB = JList( self.Plugin_list, valueChanged=self.onchange_plugins_lb)
self.Plugin_LB.setVisibleRowCount( 3 )
self.scpPlugin_LB = JScrollPane( self.Plugin_LB )
self.gbcPanel0.gridx = 6
self.gbcPanel0.gridy = 15
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 1
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.scpPlugin_LB, self.gbcPanel0 )
self.panel0.add( self.scpPlugin_LB )
self.Blank_4 = JLabel( " ")
self.Blank_4.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 17
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_4, self.gbcPanel0 )
self.panel0.add( self.Blank_4 )
self.Profile_Label_1 = JLabel( "Profile:")
self.Blank_1.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 19
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Profile_Label_1, self.gbcPanel0 )
self.panel0.add( self.Profile_Label_1 )
self.Profile_List = self.get_profiles()
self.Profile_CB = JComboBox( self.Profile_List)
self.Profile_CB.itemStateChanged = self.onchange_profile_cb
self.gbcPanel0.gridx = 6
self.gbcPanel0.gridy = 19
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 1
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Profile_CB, self.gbcPanel0 )
self.panel0.add( self.Profile_CB )
self.Blank_5 = JLabel( " ")
self.Blank_5.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 21
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_5, self.gbcPanel0 )
self.panel0.add( self.Blank_5 )
self.Label_2 = JLabel("Additional Parameters To Run With:")
self.Label_2.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 23
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_2, self.gbcPanel0 )
self.panel0.add( self.Label_2 )
self.Additional_Parms_TF = JTextField(10,focusLost=self.keyPressed)
#self.Additional_Parms_TF.getDocument().addDocumentListener()
self.Additional_Parms_TF.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 25
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Additional_Parms_TF, self.gbcPanel0 )
self.panel0.add( self.Additional_Parms_TF )
self.Blank_6 = JLabel( " ")
self.Blank_6.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 27
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Blank_6, self.gbcPanel0 )
self.panel0.add( self.Blank_6 )
self.Label_3 = JLabel( "Message:")
self.Label_3.setEnabled(True)
self.gbcPanel0.gridx = 2
self.gbcPanel0.gridy = 29
self.gbcPanel0.gridwidth = 1
self.gbcPanel0.gridheight = 1
self.gbcPanel0.fill = GridBagConstraints.BOTH
self.gbcPanel0.weightx = 1
self.gbcPanel0.weighty = 0
self.gbcPanel0.anchor = GridBagConstraints.NORTH
self.gbPanel0.setConstraints( self.Label_3, self.gbcPanel0 )
self.panel0.add( self.Label_3 )
self.add(self.panel0)
# Custom load any data field and initialize the values
def customizeComponents(self):
self.Program_Executable_TF.setText(self.local_settings.getSetting('Volatility_Directory'))
#pass
# Return the settings used
def getSettings(self):
return self.local_settings
class EditSettingsView(JDialog):
def __init__(self, controller, working_dir, servers, keystrokes, languages,
projects):
self.logger = logging.getLogger("NammuController")
self.setAlwaysOnTop(True)
self.controller = controller
self.working_dir = working_dir
self.servers = servers
self.keystrokes = keystrokes
self.languages = languages
self.projects = projects
self.pane = self.getContentPane()
def build(self):
'''
Create all tab panels and put together to form the settings window.
'''
self.setLayout(BorderLayout())
self.add(self.build_tabbed_panel(), BorderLayout.CENTER)
self.add(self.build_buttons_panel(), BorderLayout.SOUTH)
def build_tabbed_panel(self):
'''
Build panel with tabs for each of the settings editable sections.
'''
tabbed_pane = JTabbedPane()
tab_titles = ["General", "Keystrokes", "Languages", "Projects"]
for title in tab_titles:
panel = self.build_settings_panel(title.lower())
tabbed_pane.addTab(title, panel)
return tabbed_pane
def build_settings_panel(self, text):
'''
Call correspondent method to create panel for given tab text.
'''
panel = getattr(self, "build_{}_panel".format(text))()
return panel
def build_general_panel(self):
'''
Create the panel that'll go in the General tab. This should contain
options for choosing which server to use for validation as well as
default working dir.
'''
panel = JPanel(GridBagLayout())
constraints = GridBagConstraints()
constraints.insets = Insets(10, 10, 10, 10)
panel = self.build_working_dir_panel(constraints, panel)
panel = self.build_servers_panel(constraints, panel)
return panel
def build_working_dir_panel(self, constraints, panel):
'''
Working directory row: label + field + button
This is for users to browse for their preferred default directory
when opening/creating a new file.
'''
working_dir_label = JLabel("Working directory:")
constraints.weightx = 0.30
constraints.gridx = 0
constraints.gridy = 0
constraints.anchor = GridBagConstraints.EAST
panel.add(working_dir_label, constraints)
self.field = JTextField()
self.field.setEditable(False)
# Can't find an elegant way to default to something that would be
# crossplatform, and I can't leave the default field empty.
if self.working_dir['default'] != "None":
self.field.setText(self.working_dir['default'])
else:
self.field.setText(os.getcwd())
constraints.weightx = 0.60
constraints.gridx = 1
constraints.gridy = 0
constraints.fill = GridBagConstraints.HORIZONTAL
constraints.insets = Insets(10, 10, 10, 5)
panel.add(self.field, constraints)
constraints.fill = 0
button = JButton("Browse", actionPerformed=self.browse)
constraints.weightx = 0.10
constraints.gridx = 2
constraints.gridy = 0
constraints.insets = Insets(10, 0, 10, 10)
panel.add(button, constraints)
return panel
def build_servers_panel(self, constraints, panel):
'''
Server location row: label + dropdown
Contains a drop down with the servers to choose from.
'''
constraints.insets = Insets(10, 10, 80, 10)
server_label = JLabel("ORACC server location:")
constraints.weightx = 0.30
constraints.gridx = 0
constraints.gridy = 1
panel.add(server_label, constraints)
self.combo = self.build_servers_combobox()
constraints.weightx = 0.70
constraints.gridx = 1
constraints.gridy = 1
constraints.gridwidth = 2
constraints.fill = GridBagConstraints.HORIZONTAL
panel.add(self.combo, constraints)
return panel
def build_servers_combobox(self):
combo = JComboBox()
# Go through list of servers and add to combo box.
for server in self.servers.keys():
if server != "default":
combo_item = "{}: {}:{}".format(server,
self.servers[server]['url'],
self.servers[server]['port'])
combo.addItem(combo_item)
# If this item is the default one, set it as selected
if server == self.servers['default']:
combo.setSelectedItem(combo_item)
return combo
def build_buttons_panel(self):
'''
Builds the buttons panel to save or cancel changes.
TODO: Reset button to reset to defaults?
'''
panel = JPanel(FlowLayout())
panel.add(JButton('Cancel', actionPerformed=self.cancel))
panel.add(JButton('Save', actionPerformed=self.save))
return panel
def build_keystrokes_panel(self):
'''
Create the panel that'll go in the Keystrokes tab. This should contain
options for choosing which keystrokes are to be assigned to which
actions.
'''
panel = JPanel()
label = JLabel("Coming soon...")
panel.add(label, BorderLayout.CENTER)
return panel
def build_languages_panel(self):
'''
Create the panel that'll go in the Languages tab. This should contain
options for choosing which is the list of languages that can be
included from the new ATF window and their abbrv.
'''
panel = JPanel()
label = JLabel("Coming soon...")
panel.add(label, BorderLayout.CENTER)
return panel
def build_projects_panel(self):
'''
Create the panel that'll go in the Projects tab. This should contain
the list of preferred projects and a means to select which is the
preferred default.
'''
panel = JPanel()
label = JLabel("Coming soon...")
panel.add(label, BorderLayout.CENTER)
return panel
def display(self):
'''
Displays window.
'''
self.build()
self.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
self.setResizable(False)
self.setTitle("Edit settings")
self.pack()
self.setLocationRelativeTo(None)
self.visible = 1
def display_error(self, keyword):
'''
Display error message when keyword is not in settings file.
'''
pass
def cancel(self, event=None):
'''
Close window and don't save changes.
'''
self.dispose()
def save(self, event=None):
'''
Save changes made by user on local settings file.
'''
# Update only the working_dir and the server for now
# TODO: update keystrokes, projects list, etc.
working_dir = self.field.getText()
# The server format is "name: url:port". We only need "name"
server = self.combo.getSelectedItem().split(':')[0]
self.controller.update_config(working_dir, server)
# Close window
self.dispose()
def browse(self, event=None):
'''
Open new dialog for the user to select a path as default working dir.
'''
default_path = self.field.getText()
if not os.path.isdir(default_path):
default_path = os.getcwd()
fileChooser = JFileChooser(default_path)
fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
# Fixed showDialog bug using showOpenDialog instead. The former was
# duplicating the last folder name in the path due to a Java bug in
# OSX in the implementation of JFileChooser!
status = fileChooser.showOpenDialog(self)
if status == JFileChooser.APPROVE_OPTION:
self.field.setText(fileChooser.getSelectedFile().toString())
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 RegForm(JPanel):
def __init__(self):
self.nameLabel = JLabel('Owner Name : ')
self.nameField = JTextField(10)
self.mobLabel = JLabel('Mob No : ')
self.mobField = JTextField(10)
self.emailLabel = JLabel('Email : ')
self.emailField = JTextField(10)
self.vehicleLabel = JLabel('Vehicle No : ')
self.vehicleField = JTextField(10)
self.regBtn = JButton('Register', actionPerformed=self.registerVehicle)
icon = ImageIcon("Refreshp.png")
self.automateRecogBtn = JButton(
'Auto', icon, actionPerformed=self.automateRecognition)
self.setPreferredSize(Dimension(400, CENTER_Y))
self.initComponents()
def initComponents(self):
self.setLayout(GridBagLayout())
gc = GridBagConstraints()
gc.weightx = 1
gc.weighty = 1
# First Row
gc.gridy = 0
gc.weightx = 1
gc.weighty = 0.1
gc.gridx = 0
gc.fill = GridBagConstraints.NONE
gc.anchor = GridBagConstraints.LINE_END
gc.insets = Insets(0, 0, 0, 5)
self.add(self.nameLabel, gc)
gc.gridx = 1
gc.anchor = GridBagConstraints.LINE_START
gc.insets = Insets(0, 0, 0, 0)
self.add(self.nameField, gc)
# Second Row
gc.gridy += 1
gc.weightx = 1
gc.weighty = 0.1
gc.gridx = 0
gc.anchor = GridBagConstraints.LINE_END
gc.insets = Insets(0, 0, 0, 5)
self.add(self.mobLabel, gc)
gc.gridx = 1
gc.anchor = GridBagConstraints.LINE_START
gc.insets = Insets(0, 0, 0, 0)
self.add(self.mobField, gc)
#Third Row
gc.gridy += 1
gc.weightx = 1
gc.weighty = 0.1
gc.gridx = 0
gc.anchor = GridBagConstraints.FIRST_LINE_END
gc.insets = Insets(0, 0, 0, 5)
self.add(self.emailLabel, gc)
gc.weightx = 1
gc.weighty = 0.2
gc.gridx = 1
gc.anchor = GridBagConstraints.FIRST_LINE_START
gc.insets = Insets(0, 0, 0, 0)
self.add(self.emailField, gc)
#Next Row
gc.gridy += 1
gc.weightx = 1
gc.weighty = 0.1
gc.gridx = 0
gc.anchor = GridBagConstraints.FIRST_LINE_END
gc.insets = Insets(0, 0, 0, 5)
self.add(self.vehicleLabel, gc)
gc.weightx = 1
gc.weighty = 0.2
gc.gridx = 1
gc.anchor = GridBagConstraints.FIRST_LINE_START
gc.insets = Insets(0, 0, 0, 0)
self.add(self.vehicleField, gc)
gc.weightx = 1
gc.weighty = 0.2
gc.gridx = 2
gc.anchor = GridBagConstraints.FIRST_LINE_START
gc.insets = Insets(0, 0, 0, 0)
self.add(self.automateRecogBtn, gc)
#Next Row
gc.gridy += 1
gc.weightx = 1
gc.weighty = 2.0
gc.gridx = 1
gc.anchor = GridBagConstraints.FIRST_LINE_START
self.add(self.regBtn, gc)
innerBorder = BorderFactory.createTitledBorder('Register Vehicle')
outerBorder = BorderFactory.createEmptyBorder(5, 5, 5, 5)
self.setBorder(
BorderFactory.createCompoundBorder(outerBorder, innerBorder))
def registerVehicle(self, e):
print 'panel done'
name = self.nameField.getText()
mob = self.mobField.getText()
email = self.emailField.getText()
lplate = self.vehicleField.getText()
fields = [name, mob, email, lplate]
if isFieldsEmpty(fields):
dialog.improperInput('One or more fields are missing!', 'No Input')
elif not rut.isMobileNo(mob):
dialog.improperInput('Invalid mobile number', 'Invalid Input')
elif not rut.isEmail(email):
dialog.improperInput('Enter a valid email address',
'Invalid email')
else:
name = self.nameField.getText()
mob = self.mobField.getText()
email = self.emailField.getText()
lplate = self.vehicleField.getText()
lplate = rut.removeSpace(lplate)
owner = [name, mob, email]
vehicle = [lplate]
client.register_vehicle(owner, vehicle)
self.validate()
def automateRecognition(self, e):
print 'Add automate recog here !!'
plate = client.recognize_plate()
if plate:
msg = 'confirm plate:' + plate
response = dialog.dispQuestion(msg, 'confirm')
if response:
self.vehicleField.setText(plate)
client.set_progress([1, 1, 0, 0])
else:
client.set_progress([1, 0, 0, 0])
self.vehicleField.setText('')
else:
client.set_progress([1, 0, 0, 0])
dialog.dispErrorMsg('coudnot reocnize!')
class ConsoleController:
def __init__(self, parent):
self._parent = parent
self._sessions = self._parent.sessions()
self._request = None #TODO I'll need a request in order to connect to something
self._position = None #TODO I'll need a position, something to change in the header to insert the command
self._pwd = None
self._commandHistory = []
self._historyIndex = 0
self._tabComplete = []
def getMainComponent(self):
self._mainPanel = JPanel(BorderLayout())
# input
self._consolePwd = JTextField()
self._consolePwd.setEditable(False)
self._consolePwd.setText("Not initialized")
self._consoleInput = JTextField()
#Remove 'tab' low-level tab-function of jumping to other component, so I can use it
self._consoleInput.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, Collections.EMPTY_SET)
self._consoleInput.addActionListener(self.EnterPress())
self._consoleInput.addKeyListener(self.KeyPress())
self._inputPanel = JPanel(BorderLayout())
self._inputPanel.add(self._consolePwd, BorderLayout.WEST)
self._inputPanel.add(self._consoleInput, BorderLayout.CENTER)
# output
self._consoleOutput = JTextArea()
self._consoleOutput.setEditable(False)
self._consoleOutput.setForeground(Color.WHITE)
self._consoleOutput.setBackground(Color.BLACK)
self._consoleOutput.setFont(self._consoleOutput.getFont().deriveFont(12.0))
self._scrollPaneConsoleOutput = JScrollPane(self._consoleOutput)
# Add to main panel and return the main panel
self._mainPanel.add(self._scrollPaneConsoleOutput, BorderLayout.CENTER)
self._mainPanel.add(self._inputPanel, BorderLayout.SOUTH)
return self._mainPanel
def sendCommand(self, requestId, cmd, directTo):
Utils.out("ConsoleController > sendCommand > 'cmd'")
Utils.out(cmd)
if cmd == 'clear':
self.resetOutput()
self._commandHistory.append(cmd)
self.resetHistoryIndex()
self.clearCmd()
return
cmdModified = cmd
requestHttpMethod = self._parent.getRequestHttpService(requestId)
#If I use virtual persistence and there's already a pwd set
if Utils.shellController._virtualPersistence and self.pwd():
#Then always prepend 'cd <pwd>' to any command executed. In reality we
# always enter in the same directory, but because this shell keeps track
# of where the user thinks he is, and always goes to that directory first
# the illusion of a persistence is created
cmdVirtual = "cd " + self.pwd()
cmdModified = cmdVirtual + "; " + cmd
requestWithCommand = self._parent.getRequestWithCommand(requestId, cmdModified)
Thread(GetThreadForRequest(requestHttpMethod, requestWithCommand, directTo)).start()
self._commandHistory.append(cmd)
self.resetHistoryIndex()
self.clearCmd()
if Utils.shellController._virtualPersistence:
if cmd.startswith('cd '):
Utils.out("ConsoleController > sendCommand: detected 'cd '")
#ask for pwd
cmdPwd = cmdModified + "; " + Commands.pwd(Commands.OS_LINUX)
requestWithCommand = self._parent.getRequestWithCommand(requestId, cmdPwd)
Thread(GetThreadForRequest(requestHttpMethod, requestWithCommand, 'pwd')).start()
if Utils.shellController._tabCompletion:
#ask 'ls -1a' for tab-completion
# The first command, pwd is set here, but cmdVirtual ain't. But this
# also means we are at the entry directory anyway, so we can just ask ls
# and get the correct tab completion anyway
try:
cmdTabComplete = cmdVirtual + "; " + Commands.ls(Commands.OS_LINUX)
except:
cmdTabComplete = Commands.ls(Commands.OS_LINUX)
requestWithCommand = self._parent.getRequestWithCommand(requestId, cmdTabComplete)
Thread(GetThreadForRequest(requestHttpMethod, requestWithCommand, 'tabComplete')).start()
else:
if Utils.shellController._tabCompletion:
cmdTabComplete = Commands.ls(Commands.OS_LINUX)
requestWithCommand = self._parent.getRequestWithCommand(requestId, cmdTabComplete)
Thread(GetThreadForRequest(requestHttpMethod, requestWithCommand, 'tabComplete')).start()
#either way execute the requested command
def startSession(self):
#TODO when starting a session I want to test for a number of things:
# if I can reform the request to a post request and still have it work
# if base 64 is available
# if bash is available
self.setPwd(None)
if Utils.shellController._virtualPersistence and Utils.shellController._outputIsolator:
Utils.out("startSession > virtualPersistence enabled > Requesting pwd")
self.sendCommand(self._parent.currentRequestId(), Commands.pwd(Commands.OS_LINUX), 'pwd')
def appendOutput(self, text, printCommand=True):
try:
if printCommand:
self.printCommand(self._commandHistory[-1])
except:
pass
self._consoleOutput.append("\n" + text)
#auto scroll down if needed
self._consoleOutput.setCaretPosition(self._consoleOutput.getDocument().getLength())
def resetOutput(self):
Utils.setConsole('')
def printCommand(self, cmd):
self._consoleOutput.append("\n" + self._pwd + "# " + cmd)
def printCurrentCommand(self):
self.printCommand(self.cmd())
def setPwd(self, pwd):
self._pwd = pwd
if pwd is None:
self._consolePwd.setText('')
else:
self._consolePwd.setText(pwd)
Utils.consoleController._mainPanel.revalidate()
def pwd(self):
return self._pwd
def cmdHistoryCount(self):
return len(self._commandHistory) #TODO - 1
def setCmd(self, cmd):
self._consoleInput.setText(cmd)
def cmd (self):
return self._consoleInput.getText()
def clearCmd(self):
self._consoleInput.setText('')
def resetHistoryIndex(self):
self._historyIndex = self.cmdHistoryCount()
def previousCommand(self):
if self._historyIndex > 0:
self._historyIndex -= 1
self.setCmd(self._commandHistory[self._historyIndex])
def nextCommand(self):
if self._historyIndex < self.cmdHistoryCount():
self._historyIndex += 1
self.setCmd(self._commandHistory[self._historyIndex])
else:
self.clearCmd()
self.resetHistoryIndex()
def setTabComplete(self, text):
self._tabComplete = text.splitlines()
def findTabComplete(self, beginCharacters=''):
suggestions = []
if beginCharacters:
for suggestion in self._tabComplete:
Utils.debug("suggestion", suggestion)
Utils.debug("text", beginCharacters)
if suggestion[0:len(beginCharacters)] == beginCharacters:
suggestions.append(suggestion)
else:
suggestions = self._tabComplete
return suggestions
def tabComplete(self):
currentCommand = self.cmd()
Utils.debug("currentCommand", currentCommand)
if currentCommand:
commandArray = currentCommand.split(' ')
lastword = commandArray.pop()
Utils.debug("lastword", lastword)
suggestions = self.findTabComplete(lastword)
if suggestions:
if len(suggestions) > 1:
self.printCurrentCommand()
for suggestion in suggestions:
self.appendOutput(suggestion, False)
if len(suggestions) == 1:
self.setCmd(' '.join(commandArray) + ' ' + suggestions.pop())
else:
suggestions = self.findTabComplete()
if len(suggestions) > 1:
self.printCurrentCommand()
for suggestion in suggestions:
self.appendOutput(suggestion, False)
class EnterPress(ActionListener): #TODO remove: AbstractAction
def actionPerformed(self, e):
Utils.consoleController.sendCommand(Utils.shellController.currentRequestId(), Utils.consoleInput.getText(), 'console')
def keyPressed(self, e):
Utils.out("key pressed")
class KeyPress(KeyListener):
def keyTyped(self, e):
pass
def keyReleased(self, e):
if e.getKeyCode() == e.VK_DOWN:
Utils.consoleController.nextCommand()
Utils.out("released down")
if e.getKeyCode() == e.VK_UP:
Utils.consoleController.previousCommand()
Utils.out("released up")
if e.getKeyCode() == e.VK_TAB:
Utils.out("pressed tab")
Utils.consoleController.tabComplete()
def keyPressed(self, e):
pass
class BurpExtender(IBurpExtender, IContextMenuFactory, ITab, ComponentListener,
ActionListener, MouseAdapter):
# contains the messages to show in the messages table
_table_data = []
# contains the messages to translate
_messages = []
# used to keep track when to refresh the table
_reload_table = False
_sql_file = None
def registerExtenderCallbacks(self, callbacks):
self._panel = JPanel()
self._panel.setLayout(BorderLayout())
#self._panel.setSize(400,400)
# sourrounding try\except because Burp is not giving enough info
try:
# creating all the UI elements
# create the split pane
self._split_pane_horizontal = JSplitPane(
JSplitPane.HORIZONTAL_SPLIT)
self._split_panel_vertical = JSplitPane(JSplitPane.VERTICAL_SPLIT)
# create panels
self._panel_top = JPanel()
self._panel_top.setLayout(BorderLayout())
self._panel_bottom = JPanel()
self._panel_bottom.setLayout(BorderLayout())
self._panel_right = JPanel()
self._panel_right.setLayout(BorderLayout())
self._panel_request = JPanel()
self._panel_request.setLayout(BorderLayout())
self._panel_response = JPanel()
self._panel_response.setLayout(BorderLayout())
# create the tabbed pane used to show request\response
self._tabbed_pane = JTabbedPane(JTabbedPane.TOP)
# create the tabbed pane used to show aslan++\concretization file
self._tabbed_pane_editor = JTabbedPane(JTabbedPane.TOP)
# create the bottom command for selecting the SQL file and
# generating the model
self._button_generate = JButton(
'Generate!', actionPerformed=self._generate_model)
self._button_save = JButton('Save',
actionPerformed=self._save_model)
self._button_select_sql = JButton(
'Select SQL', actionPerformed=self._select_sql_file)
self._text_field_sql_file = JTextField(20)
self._panel_bottom_commands = JPanel()
layout = GroupLayout(self._panel_bottom_commands)
layout.setAutoCreateGaps(True)
layout.setAutoCreateContainerGaps(True)
seq_layout = layout.createSequentialGroup()
seq_layout.addComponent(self._text_field_sql_file)
seq_layout.addComponent(self._button_select_sql)
seq_layout.addComponent(self._button_generate)
seq_layout.addComponent(self._button_save)
layout.setHorizontalGroup(seq_layout)
# create the message editors that will be used to show request and response
self._message_editor_request = callbacks.createMessageEditor(
None, True)
self._message_editor_response = callbacks.createMessageEditor(
None, True)
# create the table that will be used to show the messages selected for
# the translation
self._columns_names = ('Host', 'Method', 'URL')
dataModel = NonEditableModel(self._table_data, self._columns_names)
self._table = JTable(dataModel)
self._scrollPane = JScrollPane()
self._scrollPane.getViewport().setView((self._table))
popmenu = JPopupMenu()
delete_item = JMenuItem("Delete")
delete_item.addActionListener(self)
popmenu.add(delete_item)
self._table.setComponentPopupMenu(popmenu)
self._table.addMouseListener(self)
# add all the elements
self._panel_request.add(
self._message_editor_request.getComponent())
self._panel_response.add(
self._message_editor_response.getComponent())
self._tabbed_pane.addTab("Request", self._panel_request)
self._tabbed_pane.addTab("Response", self._panel_response)
self._panel_top.add(self._scrollPane, BorderLayout.CENTER)
self._panel_bottom.add(self._tabbed_pane, BorderLayout.CENTER)
scroll = JScrollPane(self._panel_bottom)
self._panel_right.add(self._tabbed_pane_editor,
BorderLayout.CENTER)
self._panel_right.add(self._panel_bottom_commands,
BorderLayout.PAGE_END)
self._split_panel_vertical.setTopComponent(self._panel_top)
self._split_panel_vertical.setBottomComponent(scroll)
self._split_pane_horizontal.setLeftComponent(
self._split_panel_vertical)
self._split_pane_horizontal.setRightComponent(self._panel_right)
self._panel.addComponentListener(self)
self._panel.add(self._split_pane_horizontal)
self._callbacks = callbacks
callbacks.setExtensionName("WAFEx")
callbacks.addSuiteTab(self)
callbacks.registerContextMenuFactory(self)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
def getTabCaption(self):
return "WAFEx"
def getUiComponent(self):
try:
Platform.runLater(EditorTabUI(self))
return self._panel
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
def componentShown(self, e):
self._split_pane_horizontal.setDividerLocation(0.25)
# populate the table with the selected requests\response
try:
if self._reload_table:
print("reload")
self._table_data = [
] # empty _table_data (not too cool but quick)
for c in self._messages:
msg = c[0]
http_request = converter._byte_array_to_string(
msg.getRequest())
request_parser = HttpParser()
request_parser.execute(http_request, len(http_request))
host = msg.getHttpService().getHost()
page = request_parser.get_url()
method = request_parser.get_method()
tmp = [host, method, page]
self._table_data += [tmp]
self._table.getModel().setDataVector(self._table_data,
self._columns_names)
self._reload_table = False
except Exception as e:
print(e)
def componentHidden(self, e):
return
def componentMoved(self, e):
return
def componentResized(self, e):
self._split_pane_horizontal.setDividerLocation(0.25)
def createMenuItems(self, invocation):
ret = []
try:
if (invocation.getInvocationContext() ==
invocation.CONTEXT_TARGET_SITE_MAP_TABLE):
menu = JMenuItem("Send to WAFEx")
messages = invocation.getSelectedMessages()
def listener(e):
""" Generates a new WAFEx model. """
#self._generateWAFExModel(messages)
self._addToGeneration(messages)
menu.addActionListener(listener)
ret.append(menu)
except Exception as e:
print(e)
return ret
def mouseClicked(self, e):
""" Positions the Aslan++ editor to the selected request position. """
try:
index = self._table.getSelectedRow()
c = self._messages[index]
print(len(c))
message = c[0]
tag = c[1]
self._message_editor_request.setMessage(message.getRequest(), True)
self._message_editor_response.setMessage(message.getResponse(),
False)
if tag != None:
document = self._jfxp_aslanpp._editor.getText()
start, end = self._search_tag_position(tag, document)
self._jfxp_aslanpp._editor.moveTo(start)
self._jfxp_aslanpp._editor.selectRange(start, end)
self._jfxp_aslanpp._editor.requestFollowCaret()
self._jfxp_aslanpp._editor.requestFocus()
except Exception as e:
print(e)
def actionPerformed(self, e):
""" Performs the delete action. """
try:
index = self._table.getSelectedRow()
del self._table_data[index]
del self._messages[index]
self._table.getModel().setDataVector(self._table_data,
self._columns_names)
except Exception as e:
print(e)
def _search_tag_position(self, tag, text):
""" Searches for a particular tag in a given text and return its position. """
pattern = self._search_pattern.format(tag)
for m in re.finditer(pattern, text):
return m.start(), m.end()
def _save_model(self, e):
""" Saves the current Aslan++ model and concretization file. """
try:
chooseFile = JFileChooser()
filter_ = FileNameExtensionFilter("txt files", ["txt"])
chooseFile.addChoosableFileFilter(filter_)
ret = chooseFile.showDialog(self._panel, "Choose file")
if ret == JFileChooser.APPROVE_OPTION:
self._model_name = chooseFile.getSelectedFile().getPath()
with open("{}.aslan++".format(self._model_name), "w") as f:
skeleton = self._jfxp_aslanpp._editor.getText()
skeleton = skeleton.replace("@filename",
basename(self._model_name))
f.write(skeleton)
print("model created")
with open("{}.txt".format(self._model_name), "w") as f:
f.write(self._jfxp_concretization._editor.getText())
except Exception as e:
print(e)
def _select_sql_file(self, e):
""" Shows a JFileChooser dialog to select the SQL file to use for creating
the model. """
try:
chooseFile = JFileChooser()
filter_ = FileNameExtensionFilter("txt files", ["txt"])
chooseFile.addChoosableFileFilter(filter_)
ret = chooseFile.showDialog(self._panel, "Choose file")
if ret == JFileChooser.APPROVE_OPTION:
self._sql_file = chooseFile.getSelectedFile().getPath()
else:
self._sql_file = None
self._text_field_sql_file.setText("" + self._sql_file)
except Exception as e:
print(e)
def _addToGeneration(self, messages):
for msg in messages:
self._messages += [[msg, None]]
self._reload_table = True
def _generate_model(self, e):
if len(self._messages) <= 0:
frame = JFrame("Error")
JOptionPane.showMessageDialog(frame, "No messages!", "Error",
JOptionPane.ERROR_MESSAGE)
return
if self._sql_file == None:
frame = JFrame("Error")
replay = JOptionPane.showConfirmDialog(
frame, "No SQL file selected!\nDo you want to continue?",
"Info", JOptionPane.YES_NO_OPTION)
if replay == JOptionPane.NO_OPTION:
return
# create a new AslanppModel
model = AslanppModel()
# save _sql_file
model._sql_file = self._sql_file
for c in self._messages:
# from byte to char Request and Response
# for some reason b can be a negative value causing a crash
# so I put a check to ensure b is in the right range
msg = c[0]
if msg.getRequest() == None or msg.getResponse() == None:
# do not convert empty messages
continue
http_request = "".join(
chr(b) for b in msg.getRequest() if b >= 0 and b <= 256)
http_response = "".join(
chr(b) for b in msg.getResponse() if b >= 0 and b <= 256)
protocol = msg.getHttpService().getProtocol()
# save the tag number generate by _parseHttpRequestResponse in the _messages array
c[1] = converter._parseHttpRequestResponse(model, http_request,
http_response, protocol)
# generate the ASLan++ code
self._model, self._concrete = converter._generateWAFExModel(model)
Platform.runLater(
UpdateEditor(self._jfxp_aslanpp._editor,
self._jfxp_concretization._editor, self._model,
self._concrete))
class GroupConversationWindow(GroupConversation):
"""A GUI window of a conversation witha group of people"""
def __init__(self, group, chatui):
GroupConversation.__init__(self, group, chatui)
self.mainframe = JFrame(self.group.name)
self.headers = ["Member"]
self.memberdata = UneditableTableModel([], self.headers)
self.display = JTextArea(columns=100, rows=15, editable=0, lineWrap=1)
self.typepad = JTextField()
self.buildpane()
self.lentext = 0
def show(self):
self.mainframe.pack()
self.mainframe.show()
def hide(self):
self.mainframe.hide()
def showGroupMessage(self, sender, text, metadata=None):
self.displayText(sender + ": " + text)
def setGroupMembers(self, members):
GroupConversation.setGroupMembers(self, members)
self.updatelist()
def setTopic(self, topic, author):
topictext = "Topic: " + topic + ", set by " + author
self.mainframe.setTitle(self.group.name + ": " + topictext)
self.displayText(topictext)
def memberJoined(self, member):
GroupConversation.memberJoined(self, member)
self.updatelist()
def memberChangedNick(self, oldnick, newnick):
GroupConversation.memberChangedNick(self, oldnick, newnick)
self.updatelist()
def memberLeft(self, member):
GroupConversation.memberLeft(self, member)
self.updatelist()
#GUI code
def buildpane(self):
buttons = JPanel(doublebuffered)
buttons.add(JButton("Hide", actionPerformed=self.hidewindow))
memberpane = JTable(self.memberdata)
memberframe = JScrollPane(memberpane)
chat = JPanel(doublebuffered)
chat.setLayout(BoxLayout(chat, BoxLayout.Y_AXIS))
chat.add(JScrollPane(self.display))
self.typepad.actionPerformed = self.send
chat.add(self.typepad)
chat.add(buttons)
mainpane = self.mainframe.getContentPane()
mainpane.setLayout(BoxLayout(mainpane, BoxLayout.X_AXIS))
mainpane.add(chat)
mainpane.add(memberframe)
def displayText(self, text):
self.lentext = self.lentext + len(text)
self.display.append(text)
self.display.setCaretPosition(self.lentext)
def updatelist(self):
self.memberdata.setDataVector([self.members], self.headers)
#actionListener
def send(self, ae):
text = self.typepad.getText()
self.typepad.setText("")
if text != "" and text != None:
GroupConversation.sendText(self, text)
def hidewindow(self, ae):
self.hide()
