def getFilenames(self):
# default_path = 'C:/Users/nschiff2/Documents/MWRDGC_WSRR/Watershed_progs/StonyCreek/Stony_V1.0/' \
# 'HydrologicModels/ExistingConditions/LucasDitch/LUDT_DesignRuns'
default_path = 'C:/Users/nschiff2/Documents/MWRDGC_WSRR/Optimatics/optimizer-hecras-integration/src/HEC-HMSModels/LucasDitch/LUDT_DesignRuns'
# GUI to get filename of *.basin file for reading - this is from the source version
basinchoice = swing.JFileChooser(default_path) #FileFilter="basin"
# filter = swing.JFileChooser.FileNameExtensionFilter("*.basin files",["basin"])
# basinin.addChoosableFileFilter(filter)
basinchoice.setDialogTitle('Choose the source *.basin file (old version)')
# basinchoice.SetFileFilter(FileNameExtensionFilter('*.basin files', 'basin'))
basinfile = basinchoice.showOpenDialog(None)
self['basinin'] = str(basinchoice.selectedFile)
# GUI to get filename of *.basin file for writing - this is for the new version
basinchoice = swing.JFileChooser(default_path)
basinchoice.setDialogTitle('Choose the sink *.basin file (new version)')
basinfile = basinchoice.showOpenDialog(None)
self['basinout'] = str(basinchoice.selectedFile)
# GUI to get filename of the *.pdata file - this is for the new version
pdatachoice = swing.JFileChooser(default_path)
basinchoice.setDialogTitle('Choose the *.pdata file (new version)')
pdatafile = pdatachoice.showOpenDialog(None)
self['pdatafile'] = str(pdatachoice.selectedFile)
# GUI to get filename of the *.dss file - this is for the new version
dsschoice = swing.JFileChooser(default_path)
basinchoice.setDialogTitle('Choose the *.dss file (new version)')
dssfile = dsschoice.showOpenDialog(None)
self['dssfile'] = str(dsschoice.selectedFile)
def loadFile(self, e):
chooseFile = swing.JFileChooser()
fileDialog = chooseFile.showDialog(self.tab, "Choose file")
if fileDialog == swing.JFileChooser.APPROVE_OPTION:
file = chooseFile.getSelectedFile()
filename = file.getCanonicalPath()
fileExtension = os.path.splitext(filename)[1]
try:
loadedFile = open(filename, "r")
except IOError as e:
print "Error reading file.\n" + str(e)
self.logArea.append('\nError reading File: %s' % filename)
if fileExtension == '.gnmap':
self.nmap(loadedFile)
elif fileExtension == '.nessus':
self.nessus(loadedFile)
elif fileExtension == '.txt':
self.plaintext(loadedFile)
else:
print '\nFile %s was read but does not have the correct extension (.gnmap, .nessus, .txt).' % filename
self.logArea.append(
'\nFile %s was read but does not have the correct extension (.gnmap, .nessus, .txt).'
% filename)
def __getPlaceView( self ):
panel = swing.JPanel()
jfc = swing.JFileChooser()
jfc.setFileSelectionMode( jfc.DIRECTORIES_ONLY )
class SelectDirectory( java.awt.event.ActionListener ):
def __init__( self, co):
self.co = co
def actionPerformed( self ,event ):
ro = java.lang.String( event.getActionCommand() )
if ro.equals( jfc.APPROVE_SELECTION):
self.co.dispose()
self.co.ok = True
self.co.path = jfc.getSelectedFile().getAbsolutePath()
elif ro.equals( jfc.CANCEL_SELECTION):
self.co.dispose()
self.co.ok = False
jfc.addActionListener( SelectDirectory( self ))
panel.add( jfc )
return panel
def runOpenFileDialog(self,
title,
filetypes,
defaultextension,
multiple=False):
"""Create and run an open file dialog ."""
import os
fd = swing.JFileChooser(os.getcwd())
if filetypes:
for x in fd.getChoosableFileFilters():
fd.removeChoosableFileFilter(x)
if filetypes:
first = None
for z in filetypes:
filter = self.FileTypesFilter(z)
if first is None: first = filter
fd.addChoosableFileFilter(filter)
if first:
fd.setFileFilter(first)
ok = fd.showOpenDialog(None)
if ok == fd.APPROVE_OPTION:
f = fd.getSelectedFile()
st = f.toString()
if multiple:
st = (st, )
return st
def create(self, *args):
fc = swing.JFileChooser()
fc.showDialog(self.jd, "Create")
path = fc.getSelectedFile()
if path:
if not path.isDirectory():
if not path.exists():
apath = path.getAbsolutePath()
if not apath.endswith(".zip"):
apath = '%s.zip' % apath
try:
nfile = java.io.File(apath)
fs = java.io.FileOutputStream(nfile)
zfos = java.util.zip.ZipOutputStream(fs)
zfos.putNextEntry(java.util.zip.ZipEntry(""))
zfos.setLevel(9)
zfos.finish()
zfos.close()
storepath = nfile.getName().rstrip('.zip')
self.libraries[storepath] = apath
self.sync()
self.message.setText("%s Creation Successful" %
storepath)
except java.lang.Exception, x:
x.printStackTrace()
self.message.setText("Could not create %s" % apath)
def initUI(self):
self.tab = swing.JPanel()
# UI for Output
self.outputLabel = swing.JLabel("pMDetector Log:")
self.outputLabel.setFont(Font("Tahoma", Font.BOLD, 14))
self.outputLabel.setForeground(Color(255, 102, 52))
self.logPane = swing.JScrollPane()
self.outputTxtArea = swing.JTextArea()
self.outputTxtArea.setFont(Font("Consolas", Font.PLAIN, 12))
self.outputTxtArea.setLineWrap(True)
self.logPane.setViewportView(self.outputTxtArea)
self.clearBtn = swing.JButton("Clear Log", actionPerformed=self.clear)
self.exportBtn = swing.JButton("Export Log",
actionPerformed=self.export)
self.parentFrm = swing.JFileChooser()
# Layout
layout = swing.GroupLayout(self.tab)
layout.setAutoCreateGaps(True)
layout.setAutoCreateContainerGaps(True)
self.tab.setLayout(layout)
layout.setHorizontalGroup(layout.createParallelGroup().addGroup(
layout.createSequentialGroup().addGroup(
layout.createParallelGroup().addComponent(
self.outputLabel).addComponent(self.logPane).addComponent(
self.clearBtn).addComponent(self.exportBtn))))
layout.setVerticalGroup(layout.createParallelGroup().addGroup(
layout.createParallelGroup().addGroup(
layout.createSequentialGroup().addComponent(
self.outputLabel).addComponent(self.logPane).addComponent(
self.clearBtn).addComponent(self.exportBtn))))
def openBrowseDialog(self, button):
dialog = swing.JFileChooser()
c = dialog.showOpenDialog(None)
if dialog is not None:
if (dialog.currentDirectory
and dialog.selectedFile.name) is not None:
loc = str(dialog.currentDirectory) + os.sep + str(
dialog.selectedFile.name)
self.editBox.setText(loc)
def setPython(self, e):
selectFile = swing.JFileChooser()
returnedFile = selectFile.showDialog(self._jPanel, "Python EXE")
if returnedFile == swing.JFileChooser.APPROVE_OPTION:
file = selectFile.getSelectedFile()
self.pythonfile = file.getPath()
print 'Selected Python at ' + file.getPath()
self._jLabelPython.setText('Python set to: ' + file.getPath())
def _tomcatLoadPwdsDicts(self, event):
chooser = swing.JFileChooser()
chooser.showOpenDialog(self._tomcatMainPanel)
filePathName = ''
try:
if(chooser.getSelectedFile()) is not None:
filePathName += (str(chooser.getSelectedFile()).replace('\\', '/'))
self._tomcatMainPwd.setText(filePathName.strip())
except:
print 'Open Pwd File Error'
def getFile(self, button):
chooser = swing.JFileChooser()
c = chooser.showOpenDialog(None)
if chooser is not None:
if (chooser.currentDirectory and chooser.selectedFile.name) is not None:
self._fileLocation = str(chooser.currentDirectory) + os.sep + str(chooser.selectedFile.name)
self._fileText.setText(self._fileLocation)
else:
self._fileText.setText("File Not Valid, Try Again")
def custom_dialog(self):
filename = None
fChooser = swing.JFileChooser()
extfilter = swing.filechooser.FileNameExtensionFilter("OK", ["*"])
fChooser.addChoosableFileFilter(extfilter)
files = fChooser.showDialog(None, "URLs files")
if files == swing.JFileChooser.APPROVE_OPTION:
filename = fChooser.getSelectedFile().getPath()
return filename
def setTamper(self, e):
selectFile = swing.JFileChooser()
filter = swing.filechooser.FileNameExtensionFilter("python files", ["py"])
selectFile.addChoosableFileFilter(filter)
returnedFile = selectFile.showDialog(self._jPanel, "Tamper")
if returnedFile == swing.JFileChooser.APPROVE_OPTION:
file = selectFile.getSelectedFile()
self.tamperfile = file.getPath()
self._jLabelTamper.setText('Tamper Script: ' + file.getPath())
def RstValue(self, event):
"Get the serialized object and put it into the list"
chooser = swing.JFileChooser()
if not (chooser.showOpenDialog(self.myFrame)):
file = chooser.getSelectedFile()
filename = file.getAbsolutePath()
fp = open(filename, 'r')
self.myListModel.clear()
for line in fp.readlines():
self.myListModel.addElement(line)
fp.close()
def SaveValue(self, event):
"Serialize the default list model"
chooser = swing.JFileChooser()
if not (chooser.showSaveDialog(self.myFrame)):
file = chooser.getSelectedFile()
filename = file.getAbsolutePath()
elements = self.myListModel.elements()
fp = open(filename, 'w')
for element in elements:
fp.write(element)
fp.write('\n')
fp.close()
def setAPI(self, e):
selectFile = swing.JFileChooser()
filter = swing.filechooser.FileNameExtensionFilter("python files", ["py"])
selectFile.addChoosableFileFilter(filter)
returnedFile = selectFile.showDialog(self._jPanel, "SQLMap API")
if returnedFile == swing.JFileChooser.APPROVE_OPTION:
file = selectFile.getSelectedFile()
self.apifile = file.getPath()
print 'Selected API at ' + file.getPath()
self._jLabelAPI.setText('API set to: ' + file.getPath())
def chooseFile(self, save = True, filter = None):
rv = None
chooser = swing.JFileChooser(self.cwd)
if self.cwd != None:
curfile = io.File(self.cwd)
if curfile.isFile():
chooser.setSelectedFile(curfile)
fun = {True: chooser.showSaveDialog, False: chooser.showOpenDialog}[save]
if fun(self) == swing.JFileChooser.APPROVE_OPTION:
rv = chooser.getSelectedFile()
if rv:
rv = rv.getAbsolutePath()
self.cwd = rv
return rv
def openFile(self):
self.chooser = swing.JFileChooser(self.defaultPath)
self.chooser.setApproveButtonText("Open File")
returnVal = self.chooser.showOpenDialog(self.gui)
if returnVal == 0: #User has chosen a file, so now it can be opened
file = open(self.chooser.getSelectedFile().getPath(), 'r')
self.filename = file.name
self.gui.setFileName(self.chooser.getSelectedFile().getName())
self.gui.editor.setText(file.read())
self.gui.editor.modified = 0
self.gui.loadDifferent()
file.close()
self.defaultPath = self.chooser.getCurrentDirectory()
self.logBuffer.openLogFile(file.name)
def load(self, e):
chooseFile = swing.JFileChooser()
ret = chooseFile.showDialog(self.tab, "Choose file")
if ret == swing.JFileChooser.APPROVE_OPTION:
file = chooseFile.getSelectedFile()
filename = file.getCanonicalPath()
try:
f = open(filename, "r")
text = f.readlines()
if text:
text = [line for line in text if not line.isspace()]
text = [line.rstrip('\n') for line in text]
self.boringHeadersList.setListData(text)
except IOError as e:
print "Error reading file.\n" + str(e)
def browser(self, n):
types = [("C/C++ files", "*.c"), ("C/C++ files", "*.cpp"),
("C/C++ files", "*.h"), ("C/C++ files", "*.hpp"),
("Java files", "*.java"), ("Pascal files", "*.pas"),
("Python files", "*.py"), ("Text files", "*.txt"),
("All files", "*")]
import java.io as io
f = io.File("tmp")
parent = f.getParentFile()
f = None
fc = swing.JFileChooser(parent)
fc.setDialogTitle("Choose compare file" + n)
haveseen = {}
for z in types:
if z[0] in haveseen:
haveseen[z[0]].extend(z[1])
else:
bf = self.brwsfilter(z)
fc.addChoosableFileFilter(bf)
haveseen[z[0]] = bf
result = fc.showOpenDialog(self.top)
if result == fc.APPROVE_OPTION:
fileName = fc.getSelectedFile().getAbsolutePath()
else:
fileName = None
#fileName = tkFileDialog.askopenfilename(
# title="Choose compare file" + n,
# filetypes=types,
# defaultextension=".txt")
if fileName and len(fileName) > 0:
# The dialog also warns about this, so this may never happen.
if not g.os_path_exists(fileName):
self.show("not found: " + fileName)
fileName = None
else:
fileName = None
return fileName
def add(self, *args):
jfc = swing.JFileChooser()
jfc.showOpenDialog(self.jd)
addto = jfc.getSelectedFile()
if addto != None and addto.isFile():
try:
ziptest = java.util.zip.ZipFile(addto)
name = addto.getName()
if name.endswith('.zip'):
name = name.rstrip('.zip')
self.libraries[name] = addto.getAbsolutePath()
self.sync()
self.message.setText("Added %s Ok" % name)
except:
self.message.setText("Could not add %s" % addto.getName())
def move( self, *args ):
svalue = self.libs.getSelectedValue()
if svalue != None:
jfc = swing.JFileChooser()
jfc.setSelectedFile( java.io.File( self.libraries[ svalue ] ) )
jfc.showDialog( self.jd, "Move %s To" % svalue )
sfile = jfc.getSelectedFile()
if sfile == None:
sfile = jfc.getCurrentDirectory()
print sfile
if sfile != None:
try:
if sfile.isDirectory():
tobemoved = java.io.File( self.libraries[ svalue ] )
name = tobemoved.getName()
nlocation = java.io.File( sfile, name )
tobemoved.renameTo( nlocation )
self.libraries[ svalue ] = nlocation.getAbsolutePath()
self.sync()
self.message.setText( "Moved %s Ok" % svalue )
else:
tobemoved = java.io.File( self.libraries[ svalue ] )
del self.libraries[ svalue ]
tobemoved.renameTo( sfile )
name = sfile.getName()
name = name.rstrip( '.zip' )
self.libraries[ name ] = sfile.getAbsolutePath()
self.sync()
self.message.setText( "Moved %s Ok" % svalue )
except:
self.message.setText( "Problems Moving %s" % svalue )
def onBrowse3(self): # Get the name of the output file.
#fileName = tkFileDialog.asksaveasfilename(
# initialfile = self.defaultOutputFileName,
# title="Set output file",
# filetypes=[("Text files", "*.txt")],
# defaultextension=".txt")
import java.io as io
f = io.File("tmp")
parent = f.getParentFile()
f = None
fc = swing.JFileChooser(parent)
result = fc.showSaveDialog(self.top)
if result == fc.APPROVE_OPTION:
fileName = fc.getSelectedFile().getAbsolutePath()
else:
fileName = None
if fileName and len(fileName) > 0:
self.defaultOutputFileName = fileName
self.useOutputFileVar.set(1) # The user will expect this.
e = self.browseEntries[2]
e.setText(fileName)
def runSaveFileDialog(self, initialfile, title, filetypes,
defaultextension):
"""Create and run a save file dialog ."""
import os
#self.oops()
fd = swing.JFileChooser(os.getcwd())
if filetypes:
for x in fd.getChoosableFileFilters():
fd.removeChoosableFileFilter(x)
if filetypes:
first = None
for z in filetypes:
filter = self.FileTypesFilter(z)
if first is None: first = filter
fd.addChoosableFileFilter(filter)
if first:
fd.setFileFilter(first)
ok = fd.showSaveDialog(None)
if ok == fd.APPROVE_OPTION:
f = fd.getSelectedFile()
st = f.toString()
if not st.endswith(defaultextension):
st = st + defaultextension
return st
def newFile(self):
self.gui.editor.setText('')
self.gui.setFileName('')
self.logBuffer.resetBuffer()
self.chooser = swing.JFileChooser() #reset the filechooser to keep
def registerExtenderCallbacks(self, callbacks):
# for error handling
sys.stdout = callbacks.getStdout()
sys.stderr = callbacks.getStderr()
self._callbacks = callbacks
self._helpers = callbacks.getHelpers()
jsonFilter = FileNameExtensionFilter("JSON files", ['json'])
basePath = self._callbacks.loadExtensionSetting(SETTING_LAST_PATH)
# print("got last path {}".format(basePath))
self._collectionChooser = swing.JFileChooser(basePath)
self._collectionChooser.setFileFilter(jsonFilter)
self._environmentChooser = swing.JFileChooser(basePath)
self._environmentChooser.setFileFilter(jsonFilter)
# ### Top "buttons" pane
controlPane = swing.JPanel()
controlPane.setBorder(EmptyBorder(10, 20, 0, 10))
controlPane.setLayout(
swing.BoxLayout(controlPane, swing.BoxLayout.PAGE_AXIS))
controlPane.setAlignmentX(swing.Box.LEFT_ALIGNMENT)
box1 = swing.Box.createHorizontalBox()
box1.setAlignmentX(swing.Box.LEFT_ALIGNMENT)
box1.add(
swing.JButton('Load Collection',
actionPerformed=self.loadCollection))
self._collectionLabel = swing.JLabel("Choose a collection file")
box1.add(self._collectionLabel)
controlPane.add(box1)
box2 = swing.Box.createHorizontalBox()
box2.setAlignmentX(swing.Box.LEFT_ALIGNMENT)
box2.add(
swing.JButton('Load Environment',
actionPerformed=self.loadEnvironment))
self._environmentLabel = swing.JLabel("Choose an environment file")
box2.add(self._environmentLabel)
controlPane.add(box2)
# ### end Top "controls" pane
# ### instructions
instructionsPane = swing.JPanel(BorderLayout())
instructions = swing.JLabel()
instructions.setText("""<html><body>
<h3>Usage:</h3>
<ol>
<li>Select the Collection Postman JSON file. This should extract all discovered environment variables.</li>
<li>(Optional) Select an Environment Postman JSON file. This can be the same as the Collection file.</li>
<li>Set environment variables below.</li>
<li>Choose 'Create Requests' to create Repeater tabs.</li>
</ol>
</body></html>""")
instructionsPane.add(instructions, BorderLayout.NORTH)
# ### end instructions
# ### environment variables
envTablePane = swing.JPanel(BorderLayout())
envLabel = swing.JLabel("Environment Variables")
envLabel.setBorder(EmptyBorder(5, 5, 5, 5))
envLabel.setFont(
Font(envLabel.getFont().getName(), Font.BOLD,
envLabel.getFont().getSize() + 2))
envTablePane.add(envLabel, BorderLayout.NORTH)
self._envTable = swing.JTable(DefaultTableModel([], self._envCols))
self._envTable.setAutoCreateRowSorter(True)
self._envTable.getTableHeader().setReorderingAllowed(False)
tableMenu = swing.JPopupMenu()
tableMenu.add(swing.JMenuItem("Add New", actionPerformed=self._addEnv))
tableMenu.add(
swing.JMenuItem("Clear All", actionPerformed=self._clearEnv))
deleteMenuItem = swing.JMenuItem("Delete Row",
actionPerformed=self._deleteEnv)
deleteMenuItem.setEnabled(False)
tableMenu.add(deleteMenuItem)
self._envTable.setComponentPopupMenu(tableMenu)
listener = self._envTableListener(self)
self._envTable.addMouseListener(listener)
renderer = self._envTableRenderer()
self._envTable.setDefaultRenderer(Class.forName('java.lang.Object'),
renderer)
envTablePaneMenu = swing.JPopupMenu()
envTablePaneMenu.add(
swing.JMenuItem("Add New", actionPerformed=self._addEnv))
envTablePaneMenu.add(
swing.JMenuItem("Clear All", actionPerformed=self._clearEnv))
scrl = swing.JScrollPane(self._envTable)
scrl.setComponentPopupMenu(envTablePaneMenu)
envTablePane.add(scrl)
# ### end environment variables
# ### requests
reqTablePane = swing.JPanel(BorderLayout())
reqLabel = swing.JLabel("Requests")
reqLabel.setBorder(EmptyBorder(5, 5, 5, 5))
reqLabel.setFont(envLabel.getFont())
reqTablePane.add(reqLabel, BorderLayout.NORTH)
self._reqTable = self._reqTableClass(
DefaultTableModel([], self._reqCols))
self._reqTable.setAutoCreateRowSorter(True)
self._reqTable.getTableHeader().setReorderingAllowed(False)
self._reqTable.setAutoResizeMode(swing.JTable.AUTO_RESIZE_LAST_COLUMN)
self._reqTable.getTableHeader().setReorderingAllowed(False)
self._reqTable.getColumnModel().getColumn(0).setMaxWidth(150)
self._reqTable.getColumnModel().getColumn(0).setMinWidth(150)
self._reqTable.getColumnModel().getColumn(2).setMaxWidth(150)
self._reqTable.getColumnModel().getColumn(2).setMinWidth(150)
scrl2 = swing.JScrollPane(self._reqTable)
reqTablePane.add(scrl2)
# ### end requests
# ### Logs
logPane = swing.JPanel(BorderLayout())
buttonBox = swing.JPanel(FlowLayout(FlowLayout.LEFT, 20, 0))
requestButtonBox = swing.Box.createHorizontalBox()
self._selectButtons = [
swing.JButton('Select All', actionPerformed=self.selectAll),
swing.JButton('Select None', actionPerformed=self.selectNone),
swing.JButton('Invert Selection',
actionPerformed=self.selectInvert)
]
for btn in self._selectButtons:
requestButtonBox.add(btn)
btn.setEnabled(False)
buttonBox.add(requestButtonBox)
self._createRequestsButton = swing.JButton(
'Create Requests', actionPerformed=self.createRequests)
self._createRequestsButton.setEnabled(False)
requestButtonBox.add(self._createRequestsButton)
buttonBox.add(self._createRequestsButton)
self._logButton = swing.JButton('Clear Log',
actionPerformed=self.clearLog)
self._logButton.setEnabled(False)
buttonBox.add(self._logButton)
logPane.add(buttonBox, BorderLayout.NORTH)
self._log = swing.JTextPane()
self._log.setEditable(False)
self._log.setFont(Font("monospaced", Font.PLAIN, 12))
logPane.add(swing.JScrollPane(self._log))
# ### end Logs
# ### add panels
self._topControlsPane = swing.JSplitPane(
swing.JSplitPane.HORIZONTAL_SPLIT, controlPane, instructionsPane)
p1 = swing.JSplitPane(swing.JSplitPane.VERTICAL_SPLIT,
self._topControlsPane, envTablePane)
p2 = swing.JSplitPane(swing.JSplitPane.VERTICAL_SPLIT, p1,
reqTablePane)
p2.setResizeWeight(0.5)
self._panel = swing.JSplitPane(swing.JSplitPane.VERTICAL_SPLIT, p2,
logPane)
self._panel.setResizeWeight(0.6)
# ### end add panels
callbacks.setExtensionName(NAME)
callbacks.addSuiteTab(self)
def initUI(self):
self.tab = swing.JPanel()
# UI for Output
self.outputLabel = swing.JLabel("unauth api result:")
self.outputLabel.setFont(Font("Tahoma", Font.BOLD, 14))
self.outputLabel.setForeground(Color(255, 102, 52))
self.logPane = swing.JScrollPane()
self.outputTxtArea = swing.JTextArea()
self.outputTxtArea.setFont(Font("Consolas", Font.PLAIN, 12))
self.outputTxtArea.setLineWrap(True)
self.logPane.setViewportView(self.outputTxtArea)
self.clearBtn = swing.JButton("Clear", actionPerformed=self.clearRst)
self.exportBtn = swing.JButton("Export",
actionPerformed=self.exportRst)
self.parentFrm = swing.JFileChooser()
self.showRspContentCheckBox = JCheckBox("show rspContent")
self.showPostBodyCheckBox = JCheckBox("show post body")
self.launchBurpUnauthCheckerCheckBox = JCheckBox(
"launchBurpUnauthChecker")
#self.includeAuthParamsLabel = swing.JLabel("includeAuthParams:")
self.excludeAuthParamsLabel = swing.JLabel("excludeAuthParams:")
self.filterSuffixLabel = swing.JLabel("filterSuffix:")
self.removeAuthParamListText = self.authParamsList
#print self.removeAuthParamListText
self.removeAuthParamListTextField = JTextField(",".join(
self.removeAuthParamListText))
self.excludeAuthParamsTextField = JTextField()
self.filterSuffixTextField = JTextField(filterSuffixList)
self.onlyIncludeStatusCodeTextField = JTextField("200")
self.onlyIncludeStatusCodeLabel = JLabel("onlyIncludeStatusCode:")
self.saveAuthParamsListButton = swing.JButton(
"save", actionPerformed=self.addAndSaveAuthParam)
self.alertSaveSuccess = JOptionPane()
self.removeGetPostAuthParamsCheckBox = JCheckBox(
"replace GET/POST Auth Params with ")
self.replaceGetPostAuthParamsWithTextField = JTextField("unauthp")
self.replaceHeaderValWithLabel = JLabel("replace header value with ")
self.replaceHeaderValWithTextField = JTextField("unauthh")
self.tab.setLayout(None)
self.tab.add(self.launchBurpUnauthCheckerCheckBox)
self.tab.add(self.showRspContentCheckBox)
self.tab.add(self.showPostBodyCheckBox)
self.tab.add(self.outputLabel)
self.tab.add(self.logPane)
self.tab.add(self.clearBtn)
self.tab.add(self.exportBtn)
self.tab.add(self.removeAuthParamListTextField)
#self.tab.add(self.includeAuthParamsLabel)
self.tab.add(self.excludeAuthParamsLabel)
self.tab.add(self.filterSuffixLabel)
self.tab.add(self.excludeAuthParamsTextField)
self.tab.add(self.filterSuffixTextField)
self.tab.add(self.onlyIncludeStatusCodeTextField)
self.tab.add(self.onlyIncludeStatusCodeLabel)
self.tab.add(self.saveAuthParamsListButton)
self.tab.add(self.alertSaveSuccess)
self.tab.add(self.removeGetPostAuthParamsCheckBox)
self.tab.add(self.replaceGetPostAuthParamsWithTextField)
self.tab.add(self.replaceHeaderValWithTextField)
self.tab.add(self.replaceHeaderValWithLabel)
self.launchBurpUnauthCheckerCheckBox.setBounds(20, 10, 200, 20)
self.showRspContentCheckBox.setBounds(20, 40, 150, 30)
self.showPostBodyCheckBox.setBounds(20, 75, 150, 30)
self.outputLabel.setBounds(400, 200, 150, 50)
self.logPane.setBounds(20, 250, 900, 400)
self.clearBtn.setBounds(20, 650, 100, 30)
self.exportBtn.setBounds(820, 650, 100, 30)
self.removeAuthParamListTextField.setBounds(20, 140, 400, 30)
#self.includeAuthParamsLabel.setBounds(20,100,100,20)
self.excludeAuthParamsLabel.setBounds(580, 100, 150, 20)
self.excludeAuthParamsTextField.setBounds(580, 120, 400, 30)
self.filterSuffixLabel.setBounds(200, 40, 100, 20)
self.filterSuffixTextField.setBounds(200, 60, 500, 30)
self.onlyIncludeStatusCodeTextField.setBounds(750, 170, 120, 30)
self.onlyIncludeStatusCodeLabel.setBounds(600, 170, 190, 20)
self.saveAuthParamsListButton.setBounds(20, 180, 80, 30)
self.removeGetPostAuthParamsCheckBox.setBounds(120, 170, 280, 20)
self.replaceGetPostAuthParamsWithTextField.setBounds(380, 170, 70, 30)
self.replaceHeaderValWithLabel.setBounds(20, 100, 180, 20)
self.replaceHeaderValWithTextField.setBounds(190, 100, 70, 30)
def create_file_selecter(self, file, filter_f_n, panel):
selectFile = swing.JFileChooser()
filter = FileNameExtensionFilter(filter_f_n, file)
selectFile.addChoosableFileFilter(filter)
return selectFile.showDialog(panel, filter_f_n), selectFile
