class BurpExtender(IBurpExtender, IExtensionStateListener, IHttpListener, IProxyListener, ITab):
def registerExtenderCallbacks(self, callbacks):
self.callbacks = callbacks
self.helpers = callbacks.helpers
self.scriptpane = JTextPane()
self.scriptpane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.scrollpane = JScrollPane()
self.scrollpane.setViewportView(self.scriptpane)
self._code = compile('', '<string>', 'exec')
self._script = ''
callbacks.registerExtensionStateListener(self)
callbacks.registerProxyListener(self)
callbacks.customizeUiComponent(self.getUiComponent())
callbacks.addSuiteTab(self)
self.scriptpane.requestFocus()
def extensionUnloaded(self):
try:
self.callbacks.saveExtensionSetting(
'script', base64.b64encode(self._script))
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def processProxyMessage(self, messageIsRequest, message):
try:
globals_ = {'extender': self,
'callbacks': self.callbacks,
'helpers': self.helpers
}
locals_ = {'messageIsRequest': messageIsRequest,
'message': message
}
exec(self.script, globals_, locals_)
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def getTabCaption(self):
return 'Script'
def getUiComponent(self):
return self.scrollpane
@property
def script(self):
end = self.scriptpane.document.length
_script = self.scriptpane.document.getText(0, end)
if _script == self._script:
return self._code
self._script = _script
self._code = compile(_script, '<string>', 'exec')
return self._code
class OutputPane(object):
"""Pane for outpout of interactive session"""
def __init__(self):
self.textpane = JTextPane()
self.doc = self.textpane.getStyledDocument()
self.textpane.editable = False
style_context = StyleContext.getDefaultStyleContext()
default_style = style_context.getStyle(StyleContext.DEFAULT_STYLE)
parent_style = self.doc.addStyle("parent", default_style)
StyleConstants.setFontFamily(parent_style, "Monospaced")
input_style = self.doc.addStyle("input", parent_style)
output_style = self.doc.addStyle("output", parent_style)
StyleConstants.setForeground(output_style, awtColor.BLUE)
error_style = self.doc.addStyle("error", parent_style)
StyleConstants.setForeground(error_style, awtColor.RED)
# Do a dance to set tab size
font = Font("Monospaced", Font.PLAIN, 12)
self.textpane.setFont(font)
fm = self.textpane.getFontMetrics(font)
tabw = float(fm.stringWidth(" "*4))
tabs = [
TabStop(tabw*i, TabStop.ALIGN_LEFT, TabStop.LEAD_NONE)
for i in xrange(1, 51)
]
attr_set = style_context.addAttribute(
SimpleAttributeSet.EMPTY,
StyleConstants.TabSet,
TabSet(tabs)
)
self.textpane.setParagraphAttributes(attr_set, False)
#Dance done!
def addtext(self, text, style="input", ensure_newline=False):
doclen = self.doc.length
if ensure_newline and doclen:
if self.doc.getText(doclen - 1, 1) != '\n':
text = '\n' + text
self.doc.insertString(self.doc.length, text, self.doc.getStyle(style))
# Scroll down
self.textpane.setCaretPosition(self.doc.length)
def clear(self):
"""Remove all text"""
self.doc.remove(0, self.doc.length)
class BurpExtender(IBurpExtender, ISessionHandlingAction,
IExtensionStateListener, IHttpListener, ITab):
def registerExtenderCallbacks(self, callbacks):
self.callbacks = callbacks
self.helpers = callbacks.helpers
self.scriptpane = JTextPane()
self.scriptpane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.scrollpane = JScrollPane()
self.scrollpane.setViewportView(self.scriptpane)
self._code = compile('', '<string>', 'exec')
self._script = ''
script = callbacks.loadExtensionSetting('script')
if script:
script = base64.b64decode(script)
self.scriptpane.document.insertString(
self.scriptpane.document.length, script, SimpleAttributeSet())
self._script = script
try:
self._code = compile(script, '<string>', 'exec')
except Exception as e:
traceback.print_exc(file=self.callbacks.getStderr())
callbacks.setExtensionName("Python Scripter (modified)")
callbacks.registerSessionHandlingAction(self)
callbacks.registerExtensionStateListener(self)
callbacks.registerHttpListener(self)
callbacks.customizeUiComponent(self.getUiComponent())
callbacks.addSuiteTab(self)
self.scriptpane.requestFocus()
return
def getActionName(self):
return 'Send to Python Scripter'
def extensionUnloaded(self):
try:
self.callbacks.saveExtensionSetting('script',
base64.b64encode(self._script))
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def performAction(self, currentRequest, macroItems):
self.processHttpMessage(self.callbacks.TOOL_MACRO, 1, currentRequest,
macroItems)
return
def processHttpMessage(self,
toolFlag,
messageIsRequest,
messageInfo,
macroItems=[]):
try:
globals_ = {}
locals_ = {
'extender': self,
'callbacks': self.callbacks,
'helpers': self.helpers,
'toolFlag': toolFlag,
'messageIsRequest': messageIsRequest,
'messageInfo': messageInfo,
'macroItems': macroItems
}
exec(self.script, globals_, locals_)
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def getTabCaption(self):
return 'Script'
def getUiComponent(self):
return self.scrollpane
@property
def script(self):
end = self.scriptpane.document.length
_script = self.scriptpane.document.getText(0, end)
if _script == self._script:
return self._code
self._script = _script
self._code = compile(_script, '<string>', 'exec')
return self._code
class Console(object):
PS1 = sys.ps1
PS2 = sys.ps2
def __init__(self, burp, namespace=None):
self.burp = burp
self.log = burp.log
self._locals = dict(Burp=burp)
self._buffer = []
self.history = History(self)
if namespace is not None:
self._locals.update(namespace)
self.interp = JythonInterpreter(self, self._locals)
self.textpane = JTextPane(keyTyped=self.keyTyped,
keyPressed=self.keyPressed)
self.textpane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.burp.customizeUiComponent(self.textpane)
self.initKeyMap()
self.document.remove(0, self.document.getLength())
self.write('Burp Extender Jython Shell', prefix='')
self.write(self.PS1)
self.textpane.requestFocus()
burp.log.info('Interactive interpreter ready...')
@property
def document(self):
return self.textpane.document
def resetbuffer(self):
self._buffer = []
def keyTyped(self, event=None):
if not self.inLastLine():
event.consume()
def keyPressed(self, event):
if event.keyCode in (KeyEvent.VK_BACK_SPACE, KeyEvent.VK_LEFT):
self.backspaceListener(event)
def getText(self):
start, end = self.__getLastLineOffsets()
text = self.document.getText(start, end - start)
return text.rstrip()
def insertText(self, data):
position = self.textpane.getCaretPosition()
self.textpane.select(position, position)
self.textpane.replaceSelection(data)
self.textpane.setCaretPosition(position + len(data))
def replaceText(self, data):
start, end = self.__getLastLineOffsets()
self.textpane.select(start, end)
self.textpane.replaceSelection(data)
self.textpane.setCaretPosition(start + len(data))
def write(self, data, color=Color.black, prefix='\n'):
style = SimpleAttributeSet()
if color is not None:
style.addAttribute(StyleConstants.Foreground, color)
self.document.insertString(self.document.getLength(), prefix + data, style)
self.textpane.caretPosition = self.document.getLength()
def enterAction(self, event=None):
text = self.getText()
self._buffer.append(text)
source = '\n'.join(self._buffer)
more = self.interp.runsource(source)
if more:
self.write(self.PS2, color=Color.black)
else:
self.resetbuffer()
self.write(self.PS1)
self.history.append(text)
def deleteAction(self, event=None):
if self.inLastLine():
if self.textpane.getSelectedText():
self.document.remove(self.textpane.getSelectionStart(),
self.textpane.getSelectionEnd() - self.textpane.getSelectionStart())
elif self.textpane.getCaretPosition() < self.document.getLength():
self.document.remove(self.textpane.getCaretPosition(), 1)
def deleteEndLineAction(self, event=None):
if self.inLastLine():
position = self.textpane.getCaretPosition()
self.textpane.setSelectionStart(position)
_, end = self.__getLastLineOffsets()
self.textpane.setSelectionEnd(end - 1)
self.textpane.cut()
def homeAction(self, event=None):
if self.inLastLine():
start, end = self.__getLastLineOffsets()
self.textpane.caretPosition = start
def endAction(self, event=None):
if self.inLastLine():
start, end = self.__getLastLineOffsets()
self.textpane.caretPosition = end - 1
def pasteAction(self, event=None):
if self.inLastLine():
clipboard = Toolkit.getDefaultToolkit().getSystemClipboard()
clipboard.getContents(self.textpane)
contents = clipboard.getData(DataFlavor.stringFlavor)
lines = contents.splitlines()
for i, line in enumerate(lines):
self.insertText(line)
if i < len(lines) - 1:
self.enterAction()
def keyboardInterruptAction(self, event=None):
self.interp.runsource('raise KeyboardInterrupt\n')
self.resetbuffer()
self.write(self.PS1)
def backspaceListener(self, event=None):
start, end = self.__getLastLineOffsets()
if self.textpane.getCaretPosition() <= start and \
not self.textpane.getSelectedText():
event.consume()
def initKeyMap(self):
import platform
os_name = platform.java_ver()[-1][0]
if os_name.startswith('Win'):
exit_key = KeyEvent.VK_Z
interrupt_key = KeyEvent.VK_PAUSE
else:
exit_key = KeyEvent.VK_D
interrupt_key = KeyEvent.VK_C
bindings = [
(KeyEvent.VK_ENTER, 0, 'jython.enter', self.enterAction),
(KeyEvent.VK_DELETE, 0, 'jython.delete', self.deleteAction),
(KeyEvent.VK_HOME, 0, 'jython.home', self.homeAction),
(KeyEvent.VK_LEFT, InputEvent.META_DOWN_MASK, 'jython.home', self.homeAction),
(KeyEvent.VK_END, 0, 'jython.end', self.endAction),
(KeyEvent.VK_RIGHT, InputEvent.META_DOWN_MASK, 'jython.end', self.endAction),
(KeyEvent.VK_UP, 0, 'jython.up', self.history.historyUp),
(KeyEvent.VK_DOWN, 0, 'jython.down', self.history.historyDown),
(KeyEvent.VK_V, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask(), 'jython.paste', self.pasteAction),
(KeyEvent.VK_A, InputEvent.CTRL_MASK, 'jython.home', self.homeAction),
(KeyEvent.VK_E, InputEvent.CTRL_MASK, 'jython.end', self.endAction),
(KeyEvent.VK_K, InputEvent.CTRL_MASK, 'jython.deleteEndLine', self.deleteEndLineAction),
(KeyEvent.VK_Y, InputEvent.CTRL_MASK, 'jython.paste', self.pasteAction),
#(interrupt_key, InputEvent.CTRL_MASK, 'jython.keyboardInterrupt', self.keyboardInterruptAction),
]
keymap = JTextComponent.addKeymap('jython', self.textpane.getKeymap())
for key, modifier, name, function in bindings:
keymap.addActionForKeyStroke(
KeyStroke.getKeyStroke(key, modifier),
ActionDelegator(name, function))
self.textpane.keymap = keymap
def inLastLine(self, include=True):
start, end = self.__getLastLineOffsets()
if self.textpane.getSelectedText():
position = self.textpane.getSelectionStart()
else:
position = self.textpane.getCaretPosition()
if include is True:
return start <= position <= end
return start < position <= end
def __getLastLineOffsets(self):
firstElement = self.document.getRootElements()[0]
lines = firstElement.getElementCount()
start = firstElement.getElement(lines - 1).getStartOffset()
end = firstElement.getElement(lines - 1).getEndOffset()
line = self.document.getText(start, end - start)
if len(line) >= 4 and (line[0:4] == self.PS1 or line[0:4] == self.PS2):
return start + 4, end
return start, end
class BurpExtender(IBurpExtender, ISessionHandlingAction,
IExtensionStateListener, ITab):
def registerExtenderCallbacks(self, callbacks):
self.callbacks = callbacks
self.helpers = callbacks.helpers
self.scriptpane = JTextPane()
self.scriptpane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.scrollpane = JScrollPane()
self.scrollpane.setViewportView(self.scriptpane)
self._code = compile('', '<string>', 'exec')
self._script = ''
script = callbacks.loadExtensionSetting('script')
if script:
script = base64.b64decode(script)
self.scriptpane.document.insertString(
self.scriptpane.document.length, script, SimpleAttributeSet())
self._script = script
self._code = compile(script, '<string>', 'exec')
callbacks.registerExtensionStateListener(self)
callbacks.customizeUiComponent(self.getUiComponent())
callbacks.registerSessionHandlingAction(self)
callbacks.addSuiteTab(self)
self.scriptpane.requestFocus()
def extensionUnloaded(self):
try:
self.callbacks.saveExtensionSetting('script',
base64.b64encode(self._script))
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def getActionName(self):
return "Custom Makro Python Script"
def performAction(self, currentRequest, macroItems):
try:
globals_ = {
'extender': self,
'callbacks': self.callbacks,
'helpers': self.helpers,
'IBurpCollaboratorClientContext':
IBurpCollaboratorClientContext,
'IBurpCollaboratorInteraction': IBurpCollaboratorInteraction,
'IBurpExtender': IBurpExtender,
'IBurpExtenderCallbacks': IBurpExtenderCallbacks,
'IContextMenuFactory': IContextMenuFactory,
'IContextMenuInvocation': IContextMenuInvocation,
'ICookie': ICookie,
'IExtensionHelpers': IExtensionHelpers,
'IExtensionStateListener': IExtensionStateListener,
'IHttpListener': IHttpListener,
'IHttpRequestResponse': IHttpRequestResponse,
'IHttpRequestResponsePersisted': IHttpRequestResponsePersisted,
'IHttpRequestResponseWithMarkers':
IHttpRequestResponseWithMarkers,
'IHttpService': IHttpService,
'IInterceptedProxyMessage': IInterceptedProxyMessage,
'IIntruderAttack': IIntruderAttack,
'IIntruderPayloadGenerator': IIntruderPayloadGenerator,
'IIntruderPayloadGeneratorFactory':
IIntruderPayloadGeneratorFactory,
'IIntruderPayloadProcessor': IIntruderPayloadProcessor,
'IMenuItemHandler': IMenuItemHandler,
'IMessageEditor': IMessageEditor,
'IMessageEditorController': IMessageEditorController,
'IMessageEditorTab': IMessageEditorTab,
'IMessageEditorTabFactory': IMessageEditorTabFactory,
'IParameter': IParameter,
'IProxyListener': IProxyListener,
'IRequestInfo': IRequestInfo,
'IResponseInfo': IResponseInfo,
'IResponseKeywords': IResponseKeywords,
'IResponseVariations': IResponseVariations,
'IScanIssue': IScanIssue,
'IScannerCheck': IScannerCheck,
'IScannerInsertionPoint': IScannerInsertionPoint,
'IScannerInsertionPointProvider':
IScannerInsertionPointProvider,
'IScannerListener': IScannerListener,
'IScanQueueItem': IScanQueueItem,
'IScopeChangeListener': IScopeChangeListener,
'ISessionHandlingAction': ISessionHandlingAction,
'ITab': ITab,
'ITempFile': ITempFile,
'ITextEditor': ITextEditor,
}
locals_ = {
'currentRequest': currentRequest,
'macroItems': macroItems
}
exec(self.script, globals_, locals_)
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def getTabCaption(self):
return 'Makro Script'
def getUiComponent(self):
return self.scrollpane
@property
def script(self):
end = self.scriptpane.document.length
_script = self.scriptpane.document.getText(0, end)
if _script == self._script:
return self._code
self._script = _script
self._code = compile(_script, '<string>', 'exec')
return self._code
class BurpExtender(
IBurpExtender,
IExtensionStateListener,
IHttpListener,
ITab,
):
def registerExtenderCallbacks(self, callbacks):
self.callbacks = callbacks
self.helpers = callbacks.helpers
callbacks.setExtensionName("Burp Scripter Plus")
stdout = PrintWriter(callbacks.getStdout(), True)
stdout.println(
"""Successfully loaded Burp Scripter Plus v"""
+ VERSION
+ """\n
Repository @ https://github.com/Acceis/BurpScripterPlus
Send feedback or bug reports on twitter @G4N4P4T1"""
)
self.scriptpane = JTextPane()
self.scriptpane.setFont(
Font("Monospaced", Font.PLAIN, 12)
)
self.scrollpane = JScrollPane()
self.scrollpane.setViewportView(self.scriptpane)
self._code = compile("", "<string>", "exec")
self._script = ""
script = callbacks.loadExtensionSetting("script")
if script:
script = base64.b64decode(script)
self.scriptpane.document.insertString(
self.scriptpane.document.length,
script,
SimpleAttributeSet(),
)
self._script = script
try:
self._code = compile(
script, "<string>", "exec"
)
except Exception as e:
traceback.print_exc(
file=self.callbacks.getStderr()
)
callbacks.registerExtensionStateListener(self)
callbacks.registerHttpListener(self)
callbacks.customizeUiComponent(
self.getUiComponent()
)
callbacks.addSuiteTab(self)
self.scriptpane.requestFocus()
def extensionUnloaded(self):
try:
self.callbacks.saveExtensionSetting(
"script",
base64.b64encode(
self._script.replace(
"\nmessage.build_message()", ""
)
),
)
except Exception:
traceback.print_exc(
file=self.callbacks.getStderr()
)
return
def processHttpMessage(
self, toolFlag, messageIsRequest, messageInfo
):
try:
globals_ = {}
locals_ = {
"extender": self,
"toolFlag": toolFlag,
"messageInfo": messageInfo,
"message": get_message(
messageInfo,
self.helpers,
messageIsRequest,
self.callbacks,
),
}
exec(self.script, globals_, locals_)
except Exception:
traceback.print_exc(
file=self.callbacks.getStderr()
)
return
def getTabCaption(self):
return "Script+"
def getUiComponent(self):
return self.scrollpane
@property
def script(self):
end = self.scriptpane.document.length
_script = (
self.scriptpane.document.getText(0, end)
+ "\nmessage.build_message()"
)
if _script == self._script:
return self._code
self._script = _script
self._code = compile(_script, "<string>", "exec")
return self._code
class BurpExtender(IBurpExtender, IIntruderPayloadGeneratorFactory,
IExtensionStateListener, ITab):
#
# implement IBurpExtender
#
def registerExtenderCallbacks(self, callbacks):
callbacks.registerExtensionStateListener(self)
# 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("Super Payload")
# register ourselves as a payload generator factory
callbacks.registerIntruderPayloadGeneratorFactory(self)
# the Super Payload UI
self.scriptpane = JTextPane()
self.scriptpane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.scrollpane = JScrollPane()
self.scrollpane.setViewportView(self.scriptpane)
callbacks.customizeUiComponent(self.getUiComponent())
callbacks.addSuiteTab(self)
self.scriptpane.requestFocus()
# Compile the init script content
self._code = compile('', '<string>', 'exec')
self._script = ''
script = callbacks.loadExtensionSetting('script')
if script:
script = base64.b64decode(script)
self.scriptpane.document.insertString(
self.scriptpane.document.length, script, SimpleAttributeSet())
self._script = script
self._code = compile(script, '<string>', 'exec')
return
def createNewInstance(self, attack):
return SuperGenerator(self, attack)
def getGeneratorName(self):
return "SuperPayload"
def extensionUnloaded(self):
try:
self.callbacks.saveExtensionSetting('script',
base64.b64encode(self._script))
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def getTabCaption(self):
return 'Super Payload Script'
def getUiComponent(self):
return self.scrollpane
# Get the compiled code of user script (update or not)
@property
def script(self):
end = self.scriptpane.document.length
_script = self.scriptpane.document.getText(0, end)
if _script == self._script:
return self._code
self._script = _script
self._code = compile(_script, '<string>', 'exec')
return self._code
class BurpExtender(IBurpExtender, IExtensionStateListener, IHttpListener,
IProxyListener, ITab):
def registerExtenderCallbacks(self, callbacks):
self.callbacks = callbacks
self.helpers = callbacks.helpers
self.scriptpane = JTextPane()
self.scriptpane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.scrollpane = JScrollPane()
self.scrollpane.setViewportView(self.scriptpane)
self._code = compile('', '<string>', 'exec')
self._script = ''
callbacks.registerExtensionStateListener(self)
callbacks.registerProxyListener(self)
callbacks.customizeUiComponent(self.getUiComponent())
callbacks.addSuiteTab(self)
self.scriptpane.requestFocus()
def extensionUnloaded(self):
try:
self.callbacks.saveExtensionSetting('script',
base64.b64encode(self._script))
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def processProxyMessage(self, messageIsRequest, message):
try:
globals_ = {
'extender': self,
'callbacks': self.callbacks,
'helpers': self.helpers
}
locals_ = {
'messageIsRequest': messageIsRequest,
'message': message
}
exec(self.script, globals_, locals_)
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def getTabCaption(self):
return 'Script'
def getUiComponent(self):
return self.scrollpane
@property
def script(self):
end = self.scriptpane.document.length
_script = self.scriptpane.document.getText(0, end)
if _script == self._script:
return self._code
self._script = _script
self._code = compile(_script, '<string>', 'exec')
return self._code
class BurpExtender(IBurpExtender, IExtensionStateListener, IHttpListener, ITab,
FocusListener, ActionListener, MouseAdapter):
_version = "0.2"
_name = "PyRules"
_varsStorage = _name + "_vars"
_scriptStorage = _name + "_script"
_enabled = 0
_vars = {}
def registerExtenderCallbacks(self, callbacks):
print "Load:" + self._name + " " + self._version
self.callbacks = callbacks
self.helpers = callbacks.helpers
#Create Tab layout
self.jVarsPane = JTextPane()
self.jVarsPane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.jVarsPane.addFocusListener(self)
self.jMenuPanel = JPanel()
self.jLeftUpPanel = JPanel()
self.jEnable = JCheckBox()
self.jEnable.setFont(Font('Monospaced', Font.BOLD, 11))
self.jEnable.setForeground(Color(0, 0, 204))
self.jEnable.setText(self._name)
self.jEnable.addActionListener(self)
self.jDocs = JLabel()
self.jDocs.setFont(Font('Monospaced', Font.PLAIN, 11))
self.jDocs.setForeground(Color(51, 102, 255))
self.jDocs.setText(Strings.docs_titel)
self.jDocs.setToolTipText(Strings.docs_tooltip)
self.jDocs.addMouseListener(self)
self.jConsoleText = JTextArea()
self.jConsoleText.setFont(Font('Monospaced', Font.PLAIN, 10))
self.jConsoleText.setBackground(Color(244, 246, 247))
self.jConsoleText.setEditable(0)
self.jConsoleText.setWrapStyleWord(1)
self.jConsoleText.setRows(10)
self.jScrollConsolePane = JScrollPane()
self.jScrollConsolePane.setViewportView(self.jConsoleText)
#set initial text
self.jConsoleText.setText(Strings.console_disable)
self.jMenuPanelLayout = GroupLayout(self.jMenuPanel)
self.jMenuPanel.setLayout(self.jMenuPanelLayout)
self.jMenuPanelLayout.setHorizontalGroup(
self.jMenuPanelLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).addGroup(
self.jMenuPanelLayout.createSequentialGroup().addComponent(
self.jEnable).addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED, 205,
32767).addComponent(self.jDocs)))
self.jMenuPanelLayout.setVerticalGroup(
self.jMenuPanelLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).addGroup(
self.jMenuPanelLayout.createSequentialGroup().addGroup(
self.jMenuPanelLayout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.jEnable).addComponent(self.jDocs)).addGap(
0, 7, 32767)))
self.jConsolePane = JPanel()
self.jConsoleLayout = GroupLayout(self.jConsolePane)
self.jConsolePane.setLayout(self.jConsoleLayout)
self.jConsoleLayout.setHorizontalGroup(
self.jConsoleLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
self.jScrollConsolePane))
self.jConsoleLayout.setVerticalGroup(
self.jConsoleLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).addGroup(
GroupLayout.Alignment.TRAILING,
self.jConsoleLayout.createSequentialGroup().addComponent(
self.jScrollConsolePane, GroupLayout.DEFAULT_SIZE, 154,
32767).addContainerGap()))
self.jLeftUpPanelLayout = GroupLayout(self.jLeftUpPanel)
self.jLeftUpPanel.setLayout(self.jLeftUpPanelLayout)
self.jLeftUpPanelLayout.setHorizontalGroup(
self.jLeftUpPanelLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
self.jConsolePane, GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE,
32767).addComponent(self.jMenuPanel,
GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE))
self.jLeftUpPanelLayout.setVerticalGroup(
self.jLeftUpPanelLayout.
createParallelGroup(GroupLayout.Alignment.LEADING).addGroup(
GroupLayout.Alignment.TRAILING,
self.jLeftUpPanelLayout.createSequentialGroup().addComponent(
self.jMenuPanel, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE).addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED).addComponent(
self.jConsolePane, GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE, 32767)))
self.jScrollpaneLeftDown = JScrollPane()
self.jScrollpaneLeftDown.setViewportView(self.jVarsPane)
self.jSplitPaneLeft = JSplitPane(JSplitPane.VERTICAL_SPLIT,
self.jLeftUpPanel,
self.jScrollpaneLeftDown)
self.jSplitPaneLeft.setDividerLocation(300)
self.jScriptPane = JTextPane()
self.jScriptPane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.jScriptPane.addMouseListener(self)
self.JScrollPaneRight = JScrollPane()
self.JScrollPaneRight.setViewportView(self.jScriptPane)
self.jSplitPane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
self.jSplitPaneLeft,
self.JScrollPaneRight)
self.jSplitPane.setDividerLocation(400)
#Load saved saved settings
##Load vars
vars = callbacks.loadExtensionSetting(self._varsStorage)
if vars:
vars = base64.b64decode(vars)
else:
# try to load the example
try:
with open("examples/Simple-CSRF-vars.py") as fvars:
vars = fvars.read()
# load the default text
except:
vars = Strings.vars
## initiate the persistant variables
locals_ = {}
try:
exec(vars, {}, locals_)
except Exception as e:
print e
self._vars = locals_
## update the vars screen
self.jVarsPane.document.insertString(self.jVarsPane.document.length,
vars, SimpleAttributeSet())
##Load script
script = callbacks.loadExtensionSetting(self._scriptStorage)
if script:
script = base64.b64decode(script)
else:
# try to load the example
try:
with open("examples/Simple-CSRF-script.py") as fscript:
script = fscript.read()
# load the default text
except:
script = Strings.script
## compile the rules
self._script = script
self._code = ''
try:
self._code = compile(script, '<string>', 'exec')
except Exception as e:
print(
'{}\nReload extension after you correct the error.'.format(e))
## update the rules screen
self.jScriptPane.document.insertString(
self.jScriptPane.document.length, script, SimpleAttributeSet())
#Register Extension
callbacks.customizeUiComponent(self.getUiComponent())
callbacks.addSuiteTab(self)
callbacks.registerExtensionStateListener(self)
callbacks.registerHttpListener(self)
self.jScriptPane.requestFocus()
def getUiComponent(self):
return self.jSplitPane
def getTabCaption(self):
return self._name
def actionPerformed(self, event):
#Check box was clicked
if self.jEnable == event.getSource():
if self._enabled == 1:
self._enabled = 0
# console content shows help
self.jConsoleText.setText(Strings.console_disable)
else:
self._enabled = 1
# console content displays the current persistent variable state
self.jConsoleText.setText(Strings.console_state)
self.jConsoleText.append(pformat(self._vars))
self.jConsoleText.append(Strings.extra_line)
self.jConsoleText.append(Strings.console_log)
return
def mouseClicked(self, event):
if event.source == self.jDocs:
uri = URI.create("https://github.com/DanNegrea/PyRules")
if uri and Desktop.isDesktopSupported() and Desktop.getDesktop(
).isSupported(Desktop.Action.BROWSE):
Desktop.getDesktop().browse(uri)
return
def focusGained(self, event):
if self.jConsolePane == event.getSource():
pass
#print "Status pane gained focus" #debug
return
def focusLost(self, event):
#Reinitialize the persistent values
if self.jVarsPane == event.getSource():
# get the text from the pane
end = self.jVarsPane.document.length
vars = self.jVarsPane.document.getText(0, end)
# compute the new values
locals_ = {}
exec(vars, {}, locals_)
self._vars = locals_
# display the new result in console
self.jConsoleText.append(Strings.console_state)
self.jConsoleText.append(pformat(self._vars))
self.jConsoleText.append(Strings.extra_line)
self.jConsoleText.append(Strings.console_log)
# scroll to bottom
verticalScrollBar = self.jScrollConsolePane.getVerticalScrollBar()
verticalScrollBar.setValue(verticalScrollBar.getMaximum())
return
def extensionUnloaded(self):
try:
#Save the latestest vars and script text
## save vars
end = self.jVarsPane.document.length
vars = self.jVarsPane.document.getText(0, end)
vars = base64.b64encode(vars)
self.callbacks.saveExtensionSetting(self._varsStorage, vars)
## save script/rules
end = self.jScriptPane.document.length
script = self.jScriptPane.document.getText(0, end)
script = base64.b64encode(script)
self.callbacks.saveExtensionSetting(self._scriptStorage, script)
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
print "Unloaded" #debug
return
def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
if self._enabled == 0:
return
try:
locals_ = {
'extender': self,
'callbacks': self.callbacks,
'helpers': self.helpers,
'toolFlag': toolFlag,
'messageIsRequest': messageIsRequest,
'messageInfo': messageInfo,
'log': self.log
}
# add the _vars as gloval variables
locals_ = dict(locals_, **self._vars)
# execute the script/rules
try:
exec(self.getCode, {}, locals_)
# catch exit() call inside the rule
except SystemExit:
pass
# update the persistant variables by searching the local variables with the same name
for key in self._vars:
# assumption self._vars dictionary is smaller than locals_
if key in locals_:
self._vars[key] = locals_[key]
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
#Returns the compiled script
@property
def getCode(self):
end = self.jScriptPane.document.length
script = self.jScriptPane.document.getText(0, end)
# if the script hasn't changed return the already compile text
if script == self._script:
return self._code
self._script = script
# compile, store and return the result
self._code = compile(script, '<string>', 'exec')
return self._code
#Log the information into the console screen
def log(self, obj):
# if string just append. else use pformat from pprint
if isinstance(obj, str):
self.jConsoleText.append(obj + "\n")
else:
self.jConsoleText.append(pformat(obj) + "\n")
# scroll to bottom
verticalScrollBar = self.jScrollConsolePane.getVerticalScrollBar()
verticalScrollBar.setValue(verticalScrollBar.getMaximum())
return
class jiconsole(Console):
"""
Class jiconsole, it is the main class which handles user interaction
"""
PROMPT = sys.ps1
PROCESS = sys.ps2
BANNER = (InteractiveConsole.getDefaultBanner(),
jEdit.getProperty("console-second-line"))
def __init__(self, view):
""" Constructor, initialized all the main variables and layout """
# Initializes variables
self.view = view
self.history = History(self)
self.bs = 0
self.indenter = TabIndenter()
self.exporterConsole = None
self.executor = JythonExecutor.getExecutor()
# Creates toolbar
actions = [ ("Run.png", "jython.tooltip-run", self.runBuffer), \
("RunToBuffer.png", "jython.tooltip-run-another", self.runBufferToWindow), \
("RunAgain.png", "jython.tooltip-import", self.importBuffer), \
("MultipleResults.png", "jython.tooltip-path", self.path), \
("Open.png", "jython.tooltip-browse-path", self.browse), \
("CopyToBuffer.png", "jython.tooltip-save-session", self.savesession), \
("separator", None, None), \
("Clear.png", "jython.tooltip-restart", self.restart),
("separator", None, None),
("Parse.png", "jython.tooltip-tabnanny", self.tabnanny),
("separator", None, None),
("Help.png", "jython.tooltip-about", self.about)]
self.panel = JPanel(BorderLayout())
self.panel.add(BorderLayout.NORTH,
ToolbarHandler(actions).createToolbar())
# Creates text pane and make keybindings
# self.output = JTextPane(keyTyped = self.keyTyped, keyPressed = self.keyPressed, keyReleased = self.keyReleased)
self.output = JTextPane(keyTyped=self.keyTyped,
keyPressed=self.keyPressed)
if jEdit.getBooleanProperty("options.jython.upDownFlag"):
keyBindings = [
(KeyEvent.VK_ENTER, 0, "jython.enter", self.enter),
(KeyEvent.VK_DELETE, 0, "jython.delete", self.delete),
(KeyEvent.VK_HOME, 0, "jython.home", self.home),
(KeyEvent.VK_UP, 0, "jython.up", self.history.historyUp),
(KeyEvent.VK_DOWN, 0, "jython.down", self.history.historyDown),
(KeyEvent.VK_UP, InputEvent.CTRL_MASK,
DefaultEditorKit.upAction,
self.output.keymap.getAction(
KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0))),
(KeyEvent.VK_DOWN, InputEvent.CTRL_MASK,
DefaultEditorKit.downAction,
self.output.keymap.getAction(
KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0)))
]
else:
keyBindings = [
(KeyEvent.VK_ENTER, 0, "jython.enter", self.enter),
(KeyEvent.VK_DELETE, 0, "jython.delete", self.delete),
(KeyEvent.VK_HOME, 0, "jython.home", self.home),
(KeyEvent.VK_UP, InputEvent.CTRL_MASK, "jython.historyup", \
self.history.historyUp),
(KeyEvent.VK_DOWN, InputEvent.CTRL_MASK, "jython.historydown", \
self.history.historyDown)
]
newmap = JTextComponent.addKeymap("jython", self.output.keymap)
for (key, modifier, name, function) in keyBindings:
newmap.addActionForKeyStroke(KeyStroke.getKeyStroke(key, modifier),
ActionDelegator(name, function))
self.output.keymap = newmap
self.doc = self.output.document
self.panel.add(BorderLayout.CENTER, JScrollPane(self.output))
self.__propertiesChanged()
self.__inittext()
self.initialLocation = self.doc.createPosition(self.doc.length - 1)
def browse(self, event):
""" Opens the browse window """
self.view.dockableWindowManager.toggleDockableWindow(
"jython-browser-dockable")
def stop(self, event):
""" Stops the current execution """
self.executor.interruptCurrent(self)
def about(self, event):
""" Opens the about dialog """
from jiabout import AboutDialog
a = AboutDialog(self.view, jEdit.getProperty("jython.about.title"))
centerDialog(a)
a.setVisible(1)
def savesession(self, event):
""" Saves the current session """
from exportsession import export
export(self.view, self.doc)
def path(self, event):
""" Opens the Path Handler """
from pathhandler import PyPathHandler
v = PyPathHandler(self.view, sys)
v.pack()
centerDialog(v)
v.visible = 1
def __buffer(self):
"""
Returns the current buffer ready for run/import, checking if it is
a python buffer and whether has been saved
"""
from javax.swing import JOptionPane
buf = self.view.editPane.buffer
if buf.mode.name != "python":
if buf.getProperty("jython.originator"):
buf = buf.getProperty("jython.originator")
if buf.mode.name == "python":
if buf.dirty:
if not jEdit.getBooleanProperty("options.jython.autosave"):
if jEdit.getBooleanProperty("options.jython.saveask"):
result = JOptionPane.showConfirmDialog(
self.panel, "Do you want to save before running",
"Confirm", JOptionPane.YES_NO_CANCEL_OPTION)
if result == JOptionPane.CANCEL_OPTION:
return None
if result == JOptionPane.YES_OPTION:
buf.save(self.view, None)
else:
buf.save(self.view, None)
return buf
return None
def runBuffer(self, event):
""" Runs the current buffer """
buffer = self.__buffer()
if buffer:
JythonExecutor.getExecutor().execBuffer(self.view, buffer, self)
def runBufferToWindow(self, event):
""" Runs the current buffer to and exports the result to another window """
from exportconsole import ConsoleToBuffer
buffer = self.__buffer()
if buffer:
if jEdit.getBooleanProperty("options.jython.reuseOutputBuffer"):
if not self.exporterConsole:
self.exporterConsole = ConsoleToBuffer(self.view, buffer)
self.exporterConsole.clear()
else:
self.exporterConsole = ConsoleToBuffer(self.view, buffer)
JythonExecutor.getExecutor().execBuffer(self.view, buffer,
self.exporterConsole)
def tabnanny(self, event):
import jitabnanny
buffer = self.__buffer()
jitabnanny.checkBuffer(buffer)
def importBuffer(self, event):
""" Imports the current buffer """
import os.path
import imp
b = self.__buffer()
if b:
modname, ext = os.path.splitext(os.path.basename(b.path))
if sys.modules.has_key(modname):
mod = sys.modules[modname]
else:
mod = imp.new_module(modname)
sys.modules[modname] = mod
mod.__file__ = b.path
setattr(sys.modules['__main__'], modname, mod)
dir = os.path.dirname(b.path)
dir = os.path.normpath(os.path.abspath(dir))
if dir not in sys.path:
sys.path.insert(0, dir)
JythonExecutor.getExecutor().importBuffer(self.view, b, self)
def restart(self, event):
""" Reinitializes the interpreter """
from javax.swing import JOptionPane
result = JOptionPane.showConfirmDialog(self.panel, \
jEdit.getProperty("jython.console.clean-confirm"), "Confirm", JOptionPane.YES_NO_CANCEL_OPTION)
if result == JOptionPane.YES_OPTION:
JythonExecutor.getExecutor().interrupt()
self.__inittext()
def inLastLine(self, include=1):
""" Determines whether the cursor is in the last line """
limits = self.__lastLine()
caret = self.output.caretPosition
if self.output.selectedText:
caret = self.output.selectionStart
if include:
return (caret >= limits[0] and caret <= limits[1])
else:
return (caret > limits[0] and caret <= limits[1])
def enter(self, event):
""" Triggered when enter is pressed """
offsets = self.__lastLine()
text = self.doc.getText(offsets[0], offsets[1] - offsets[0])
# Detects special keywords
if text != "\n":
if text[:-1] == "copyright":
self.printResult(
jEdit.getProperty("jython.interpreter.copyright") +
sys.copyright)
self.printPrompt()
return
if text[:-1] == "credits":
import site
self.printResult(
jEdit.getProperty("jython.interpreter.credits") + "\n" +
str(site.__builtin__.credits))
self.printPrompt()
return
if text[:-1] == "license":
import site
self.printResult(
jEdit.getProperty("jython.interpreter.license"))
self.printPrompt()
return
text = text[:-1]
if self.indenter.isPushable(text):
JythonExecutor.getExecutor().execute(self.view, text, self)
self.history.append(text)
else:
self.printOnProcess()
else:
JythonExecutor.getExecutor().execute(self.view, text, self)
def home(self, event):
""" Triggered when HOME is pressed """
if self.inLastLine():
self.output.caretPosition = self.__lastLine()[0]
else:
lines = self.doc.rootElements[0].elementCount
for i in xrange(0, lines - 1):
offsets = (self.doc.rootElements[0].getElement(i).startOffset, \
self.doc.rootElements[0].getElement(i).endOffset)
line = self.doc.getText(offsets[0], offsets[1] - offsets[0])
if self.output.caretPosition >= offsets[0] and \
self.output.caretPosition <= offsets[1]:
if line.startswith(jiconsole.PROMPT) or line.startswith(
jiconsole.PROCESS):
self.output.caretPosition = offsets[0] + len(
jiconsole.PROMPT)
else:
self.output.caretPosition = offsets[0]
def replaceRow(self, text):
""" Replaces the last line of the textarea with text """
offset = self.__lastLine()
last = self.doc.getText(offset[0], offset[1] - offset[0])
if last != "\n":
self.doc.remove(offset[0], offset[1] - offset[0] - 1)
self.__addOutput(self.infoColor, text)
def delete(self, event):
""" Intercepts delete events only allowing it to work in the last line """
if self.inLastLine():
if self.output.selectedText:
self.doc.remove(
self.output.selectionStart,
self.output.selectionEnd - self.output.selectionStart)
elif self.output.caretPosition < self.doc.length:
self.doc.remove(self.output.caretPosition, 1)
def keyReleased(self, event):
""" Experimental code completion, disabled for now """
if event.keyChar == '.':
offsets = self.__lastLine()
text = self.doc.getText(offsets[0], offsets[1] - offsets[0] - 1)
#completions = jintrospect.getAutoCompleteList(text, globals())
completions = 0
if completions:
CompletionPopup(self.view, completions, self.output, self)
def keyTyped(self, event):
if not self.inLastLine():
event.consume()
if self.bs:
event.consume()
self.bs = 0
def keyPressed(self, event):
if event.keyCode == KeyEvent.VK_BACK_SPACE:
offsets = self.__lastLine()
if not self.inLastLine(include=0):
self.bs = 1
else:
self.bs = 0
def printResult(self, msg):
""" Prints the results of an operation """
self.__addOutput(self.output.foreground, "\n" + str(msg))
def printOnProcess(self):
""" Prints the process symbol """
self.__addOutput(self.infoColor, "\n" + jiconsole.PROCESS)
def printPrompt(self):
""" Prints the prompt """
self.__addOutput(self.infoColor, "\n" + jiconsole.PROMPT)
def printErrorMsg(self, msg, file, line):
self.__addOutput(self.errorColor, "\n" + str(msg))
self.__addErrorButton((file, line))
def printError(self, e):
import org
self.__addOutput(self.errorColor, "\n%s" % str(e)[:-1])
if isinstance(e, org.python.core.PySyntaxError):
self.__addErrorButton((e.value[1][0], e.value[1][1]))
elif isinstance(e, org.python.core.PyException):
import traceback
self.__addErrorButton((traceback.extract_tb(e.traceback)[-1][0],
traceback.extract_tb(e.traceback)[-1][1]))
def _completeToken(self, token):
""" Adds a token to be completed """
style = SimpleAttributeSet()
style.addAttribute(StyleConstants.Foreground, self.infoColor)
self.doc.insertString(self.output.caretPosition, token, style)
def __addOutput(self, color, msg):
""" Adds the output to the text area using a given color """
style = SimpleAttributeSet()
if color:
style.addAttribute(StyleConstants.Foreground, color)
self.doc.insertString(self.doc.length, msg, style)
self.output.caretPosition = self.doc.length
def __propertiesChanged(self):
""" Detects when the properties have changed """
self.output.background = jEdit.getColorProperty("jython.bgColor")
self.output.foreground = jEdit.getColorProperty("jython.resultColor")
self.infoColor = jEdit.getColorProperty("jython.textColor")
self.errorColor = jEdit.getColorProperty("jython.errorColor")
family = jEdit.getProperty("jython.font", "Monospaced")
size = jEdit.getIntegerProperty("jython.fontsize", 14)
style = jEdit.getIntegerProperty("jython.fontstyle", Font.PLAIN)
self.output.setFont(Font(family, style, size))
def __inittext(self):
""" Inserts the initial text with the jython banner """
self.doc.remove(0, self.doc.length)
for line in "\n".join(jiconsole.BANNER):
self.__addOutput(self.infoColor, line)
self.printPrompt()
self.output.requestFocus()
def __lastLine(self):
""" Returns the char offsets of the last line """
lines = self.doc.rootElements[0].elementCount
offsets = (self.doc.rootElements[0].getElement(lines-1).startOffset, \
self.doc.rootElements[0].getElement(lines-1).endOffset)
line = self.doc.getText(offsets[0], offsets[1] - offsets[0])
if len(line) >= 4 and (line[0:4] == jiconsole.PROMPT
or line[0:4] == jiconsole.PROCESS):
return (offsets[0] + len(jiconsole.PROMPT), offsets[1])
return offsets
def __addErrorButton(self, parsed):
from error import ErrorButton
if parsed[0] != "<console>":
self.__addOutput(self.errorColor, " ")
self.output.insertComponent(ErrorButton(self.view, parsed))
class BurpExtender(IBurpExtender, IExtensionStateListener, IHttpListener,
ITab):
def registerExtenderCallbacks(self, callbacks):
self.callbacks = callbacks
self.helpers = callbacks.helpers
self.scriptpane = JTextPane()
self.scriptpane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.scrollpane = JScrollPane()
self.scrollpane.setViewportView(self.scriptpane)
self._code = compile('', '<string>', 'exec')
self._script = ''
script = callbacks.loadExtensionSetting('script')
if script:
script = base64.b64decode(script)
self.scriptpane.document.insertString(
self.scriptpane.document.length, script, SimpleAttributeSet())
self._script = script
try:
self._code = compile(script, '<string>', 'exec')
except Exception as e:
traceback.print_exc(file=self.callbacks.getStderr())
callbacks.registerExtensionStateListener(self)
callbacks.registerHttpListener(self)
callbacks.customizeUiComponent(self.getUiComponent())
callbacks.addSuiteTab(self)
self.scriptpane.requestFocus()
def extensionUnloaded(self):
try:
self.callbacks.saveExtensionSetting('script',
base64.b64encode(self._script))
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
try:
globals_ = {'postToAPI': self.postToAPI}
locals_ = {
'extender': self,
'callbacks': self.callbacks,
'helpers': self.helpers,
'toolFlag': toolFlag,
'messageIsRequest': messageIsRequest,
'messageInfo': messageInfo
}
exec(self.script, globals_, locals_)
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def getTabCaption(self):
return 'Script'
def getUiComponent(self):
return self.scrollpane
def postToAPI(self, api_url, action, charset, postData):
reqdata = {'action': action, 'charset': charset, 'postData': postData}
headers = {'Content-Type': 'application/json'}
req = urllib2.Request(url=api_url,
headers=headers,
data=json.dumps(reqdata))
res_data = urllib2.urlopen(req)
@property
def script(self):
end = self.scriptpane.document.length
_script = self.scriptpane.document.getText(0, end)
if _script == self._script:
return self._code
self._script = _script
self._code = compile(_script, '<string>', 'exec')
return self._code
class BurpExtender(IBurpExtender, IExtensionStateListener, IHttpListener, ITab):
def registerExtenderCallbacks(self, callbacks):
self.callbacks = callbacks
self.helpers = callbacks.helpers
# text pane
self.scriptpane = JTextPane()
self.scriptpane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.scrollpane = JScrollPane()
self.scrollpane.setViewportView(self.scriptpane)
# compile to bytecode
self._code = compile('', '<string>', 'exec')
self._script = ''
# load configuration settings for the extension that were saved using the method saveExtensionSetting().
script = callbacks.loadExtensionSetting('script')
if script:
script = base64.b64decode(script)
self.scriptpane.document.insertString(
self.scriptpane.document.length,
script,
SimpleAttributeSet())
self._script = script
self._code = compile(script, '<string>', 'exec')
# register
callbacks.registerExtensionStateListener(self)
callbacks.registerHttpListener(self)
# ui
callbacks.customizeUiComponent(self.getUiComponent())
callbacks.addSuiteTab(self)
self.scriptpane.requestFocus()
#
# extender unload
#
def extensionUnloaded(self):
try:
# save script, base64 encode
self.callbacks.saveExtensionSetting(
'script', base64.b64encode(self._script))
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
#
# implement IHttpListener
#
def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
try:
globals_ = {'extender': self,
'callbacks': self.callbacks,
'helpers': self.helpers
}
locals_ = {'toolFlag': toolFlag,
'messageIsRequest': messageIsRequest,
'messageInfo': messageInfo
}
exec(self.script, globals_, locals_)
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
#
# implement ITab
#
def getTabCaption(self):
return 'Script'
def getUiComponent(self):
return self.scrollpane
#
# script 不变时，不用重复编译， 优化性能
#
@property
def script(self):
end = self.scriptpane.document.length
_script = self.scriptpane.document.getText(0, end)
if _script == self._script:
return self._code
self._script = _script
self._code = compile(_script, '<string>', 'exec')
return self._code
def __init__(self, ui):
JSplitPane.__init__(self, JSplitPane.HORIZONTAL_SPLIT)
self._ui = ui
# create the executor object
self._executor = Executor(self, ui.callbacks)
####
# start Left Top split layout
jLeftTopPanel = JPanel()
jMenuPanel = JPanel()
#Load button
self.jLoad = JButton(Strings.jLoad_text)
self.jLoad.addActionListener(self)
#File name text field
self.jFileName = JTextField(Strings.jFileName_default, 30)
self.jFileName.setHorizontalAlignment(JTextField.CENTER)
self.jFileName.setEditable(False)
#Save button
self.jSave = JButton(Strings.jSave_text)
self.jSave.addActionListener(self)
#Exit button
self.jExit = JButton(Strings.jExit_text)
self.jExit.addActionListener(self)
#Wiki button (URL)
self.jWiki = JButton(Strings.jWiki_title)
self.jWiki.setToolTipText(Strings.jWiki_tooltip)
self.jWiki.addActionListener(self)
# make it borderless
self.jWiki.setBorder(EmptyBorder(0, 0, 0, 0))
self.jWiki.setBorderPainted(False)
self.jWiki.setContentAreaFilled(False)
#Console text area
jConsoleText = JTextArea()
jConsoleText.setEditable(0)
jConsoleText.setWrapStyleWord(1)
jConsoleText.setRows(10)
#set initial text
jConsoleText.setText(Strings.jConsoleText_help)
#make scrollable
jScrollConsolePane = JScrollPane()
jScrollConsolePane.setViewportView(jConsoleText)
jMenuPanelLayout = GroupLayout(jMenuPanel)
jMenuPanel.setLayout(jMenuPanelLayout)
jMenuPanelLayout.setHorizontalGroup(
jMenuPanelLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).
addGroup(jMenuPanelLayout.createSequentialGroup().addContainerGap(
).addComponent(self.jLoad).addComponent(
self.jFileName).addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED).addComponent(
self.jSave).addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED).
addComponent(self.jWiki).addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED).addComponent(
self.jExit).addContainerGap()))
jMenuPanelLayout.setVerticalGroup(
jMenuPanelLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).addGroup(
jMenuPanelLayout.createSequentialGroup().addGroup(
jMenuPanelLayout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.jLoad).addComponent(
self.jFileName, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE).addComponent(
self.jSave).addComponent(
self.jWiki).addComponent(
self.jExit))))
jLeftTopPanelLayout = GroupLayout(jLeftTopPanel)
jLeftTopPanel.setLayout(jLeftTopPanelLayout)
jLeftTopPanelLayout.setHorizontalGroup(
jLeftTopPanelLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
jMenuPanel, GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE).addComponent(
jScrollConsolePane, GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE, 32767))
jLeftTopPanelLayout.setVerticalGroup(
jLeftTopPanelLayout.
createParallelGroup(GroupLayout.Alignment.LEADING).addGroup(
GroupLayout.Alignment.TRAILING,
jLeftTopPanelLayout.createSequentialGroup().addComponent(
jMenuPanel, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE).addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED).addComponent(
jScrollConsolePane, GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE, 32767)))
# end Left Top split layout
####
####
# start Left Down split layout
jLeftDownPanel = JPanel()
jMenu2Panel = JPanel()
#Clear button
self.jClear = JButton(Strings.jClear_text)
self.jClear.setToolTipText(Strings.jClear_tooltip)
self.jClear.addActionListener(self)
#Run button
self.jRun = JButton(Strings.jRun_text)
self.jRun.setToolTipText(Strings.jRun_tooltip)
self.jRun.addActionListener(self)
#Variables text area
jVarsPane = JTextPane()
jVarsPane.setFont(Font('Monospaced', Font.PLAIN, 11))
jVarsPane.addFocusListener(self)
# set initial value
jVarsPane.setText(Strings.jVarsPane_header)
# make scrollable
jScrollpaneLeftDown = JScrollPane()
jScrollpaneLeftDown.setViewportView(jVarsPane)
jMenu2PanelLayout = GroupLayout(jMenu2Panel)
jMenu2Panel.setLayout(jMenu2PanelLayout)
jMenu2PanelLayout.setHorizontalGroup(
jMenu2PanelLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).addGroup(
jMenu2PanelLayout.createSequentialGroup().addContainerGap(
).addComponent(self.jClear).addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED, 100,
32767).addComponent(self.jRun).addContainerGap()))
jMenu2PanelLayout.setVerticalGroup(
jMenu2PanelLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).addGroup(
jMenu2PanelLayout.createSequentialGroup().addGroup(
jMenu2PanelLayout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.jClear).addComponent(self.jRun))))
jLeftDownPanelLayout = GroupLayout(jLeftDownPanel)
jLeftDownPanel.setLayout(jLeftDownPanelLayout)
jLeftDownPanelLayout.setHorizontalGroup(
jLeftDownPanelLayout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
jMenu2Panel, GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE).addComponent(
jScrollpaneLeftDown, GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE, 32767))
jLeftDownPanelLayout.setVerticalGroup(
jLeftDownPanelLayout.
createParallelGroup(GroupLayout.Alignment.LEADING).addGroup(
GroupLayout.Alignment.TRAILING,
jLeftDownPanelLayout.createSequentialGroup().addComponent(
jMenu2Panel, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE).addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED).addComponent(
jScrollpaneLeftDown, GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE, 32767)))
# end Left Down split layout
####
####
# start Left layout
jSplitPaneLeft = JSplitPane(JSplitPane.VERTICAL_SPLIT, jLeftTopPanel,
jLeftDownPanel)
jSplitPaneLeft.setDividerLocation(300)
# end Left layout
####
####
# start Right layout
jScriptPane = JTextPane()
jScriptPane.setFont(Font('Monospaced', Font.PLAIN, 11))
# set initial value
jScriptPane.setText(Strings.jScriptPane_header)
#jScriptPane.addMouseListener(self)
jScrollPaneRight = JScrollPane()
jScrollPaneRight.setViewportView(jScriptPane)
# end Right layout
####
self.setLeftComponent(jSplitPaneLeft)
self.setRightComponent(jScrollPaneRight)
self.setDividerLocation(450)
#Exported variables
self.jConsoleText = jConsoleText
self.jScrollConsolePane = jScrollConsolePane
self.jScriptPane = jScriptPane
self.jVarsPane = jVarsPane
class BurpExtender(IBurpExtender, IIntruderPayloadGeneratorFactory, IExtensionStateListener, ITab):
#
# implement IBurpExtender
#
def registerExtenderCallbacks(self, callbacks):
callbacks.registerExtensionStateListener(self)
# 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("Super Payload")
# register ourselves as a payload generator factory
callbacks.registerIntruderPayloadGeneratorFactory(self)
# the Super Payload UI
self.scriptpane = JTextPane()
self.scriptpane.setFont(Font('Monospaced', Font.PLAIN, 11))
self.scrollpane = JScrollPane()
self.scrollpane.setViewportView(self.scriptpane)
callbacks.customizeUiComponent(self.getUiComponent())
callbacks.addSuiteTab(self)
self.scriptpane.requestFocus()
# Compile the init script content
self._code = compile('', '<string>', 'exec')
self._script = ''
script = callbacks.loadExtensionSetting('script')
if script:
script = base64.b64decode(script)
self.scriptpane.document.insertString(
self.scriptpane.document.length,
script,
SimpleAttributeSet())
self._script = script
self._code = compile(script, '<string>', 'exec')
return
def createNewInstance(self, attack):
return SuperGenerator(self, attack)
def getGeneratorName(self):
return "SuperPayload"
def extensionUnloaded(self):
try:
self.callbacks.saveExtensionSetting(
'script', base64.b64encode(self._script))
except Exception:
traceback.print_exc(file=self.callbacks.getStderr())
return
def getTabCaption(self):
return 'Super Payload Script'
def getUiComponent(self):
return self.scrollpane
# Get the compiled code of user script (update or not)
@property
def script(self):
end = self.scriptpane.document.length
_script = self.scriptpane.document.getText(0, end)
if _script == self._script:
return self._code
self._script = _script
self._code = compile(_script, '<string>', 'exec')
return self._code
class DialogPanel(Panel):
manImage = None #image
manImageSilent = None
manLabel = None #label
dialogText = None
dialogTextScroller = None
buttonsPanel = None
def speak(self, text):
self.dialogText.setText("")
self.manLabel.setIcon(self.manImage)
class Typer(threading.Thread):
def __init__(thrd, text):
threading.Thread.__init__(thrd)
thrd.text = text
def run(thrd):
text = thrd.text
for i in range(0, len(text)):
if text[i] == '-':
time.sleep(.05)
pass
self.dialogText.setText(self.dialogText.getText() +
text[i])
time.sleep(.1)
self.manLabel.setIcon(self.manImageSilent)
Typer(text).start()
def __init__(self, inconsolePanel):
self.consolePanel = inconsolePanel
Panel.__init__(self, "insets 0 0 0 0")
self.speak(
"My name is Captain danglewood! Help me find my lost crew in this hell pit of unix!!!"
)
def initUI(self):
self.manImage = ImageIcon('bin/gui/media/' + "danglewood.gif")
self.manImageSilent = ImageIcon('bin/gui/media/' +
"danglewood-silent.png")
self.manLabel = JLabel(self.manImage)
self.dialogText = JTextPane()
self.dialogText.setEditable(False)
self.dialogTextScroller = JScrollPane(self.dialogText)
self.dialogText.setBackground(Color(0, 24, 0))
self.dialogText.setForeground(Color.WHITE)
self.dialogText.setFont(Font("Arial", Font.BOLD, 15))
self.buttonsPanel = ButtonPanel(self.consolePanel, self)
self.dialogText.setText("Welcome to BashED!!!")
def addUI(self):
self.add(self.buttonsPanel, "cell 0 0, pushy, growy")
self.add(self.dialogTextScroller, "cell 1 0, push, grow")
self.add(self.manLabel, "cell 2 0")
class EditorPanel_text_utf_8(EditorPanel_abstract):
def basicRecordChanged(self, newRecord):
self.textEditor.caretPosition = 0
self.saveButton.background = self.normalSaveButtonColor
def makeComponents(self):
# text specific operations
self.randomUUIDButton = JButton("Generate random UUID", actionPerformed=self.randomUUIDPressed)
self.clearButton = JButton("Clear", actionPerformed=self.clearPressed)
self.runButton = JButton("Run as Jython", actionPerformed=self.runPressed)
self.revertButton = JButton("Revert", actionPerformed=self.revertPressed)
self.buttonPanel = Box(BoxLayout.X_AXIS)
self.buttonPanel.add(Box.createRigidArea(Dimension(5,0)))
self.buttonPanel.add(self.randomUUIDButton)
self.buttonPanel.add(Box.createRigidArea(Dimension(5,0)))
self.buttonPanel.add(self.clearButton)
self.buttonPanel.add(Box.createRigidArea(Dimension(5,0)))
self.buttonPanel.add(self.runButton)
self.buttonPanel.add(Box.createRigidArea(Dimension(5,0)))
self.buttonPanel.add(self.revertButton)
self.buttonPanel.add(Box.createRigidArea(Dimension(5,0)))
self.textEditor = JTextPane()
self.textEditor.setFont(Font("monospaced", Font.PLAIN, 12))
#self.textEditor.setTabSize(4) # still inserts tabs instead of spaces
TabKeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0, False)
MyTabActionKey = Object()
self.textEditor.getInputMap().put(TabKeyStroke, MyTabActionKey)
actionMap = self.textEditor.getActionMap()
actionMap.put(MyTabActionKey, AddFourSpacesAction())
self.layout = BorderLayout()
self.add(self.buttonPanel, BorderLayout.NORTH)
self.add(JScrollPane(self.textEditor), BorderLayout.CENTER)
def basicGetCurrentValueBytes(self):
return self.textEditor.text
def basicSetCurrentValueBytes(self, newValueBytes):
self.textEditor.text = newValueBytes
self.textEditor.caretPosition = 0
# extra functionality
def runPressed(self, event):
print "run pressed"
codeText = self.getCurrentValueBytes()
print "=== run code ==="
exec "from token import *"
#print codeText
self.browser.oldimport = __builtin__.__import__
self.browser.contextUUID = self.browser.entitiesList.selectedValue
__builtin__.__import__ = self.browser.importCodeFromRepository
self.browser.importLevel = 0
try:
try:
someGlobals = {"currentBrowser": self.browser, "contextUUID": self.browser.entitiesList.selectedValue}
exec codeText in someGlobals
except SyntaxError, e:
print e
#print "fileName", e.fileName
#print "lineno", e.lineno
print "offset:", e.offset
print "text:", e.text
lines = codeText.split('\n')
position = 0
for i in range(e.lineno - 1):
position += len(lines[i]) + 1
position += e.offset
self.textEditor.caretPosition = position
self.textEditor.requestFocus()
print "=== done ==="
finally:
