def _updateActionRecentDocuments(self):
# Add items to the list, if necessary
for idx in range(len(self._actionRecentDocuments)+1, self._preferences.maximumRecentDocuments()+1):
actionRecentDocument = QAction(self)
actionRecentDocument.setObjectName(f"actionRecentDocument_{idx}")
actionRecentDocument.triggered.connect(lambda data=actionRecentDocument.data(): self._onActionOpenRecentDocumentTriggered(data))
self._actionRecentDocuments.append(actionRecentDocument)
# Remove items from the list, if necessary
while len(self._actionRecentDocuments) > self._preferences.maximumRecentDocuments():
self._actionRecentDocuments.pop()
# Update items
for idx in range(len(self._actionRecentDocuments)):
text = None
data = None
show = False
if idx < len(self._recentDocuments):
text = self.tr("{0} [{1}]").format(QFileInfo(self._recentDocuments[idx]).fileName(), self._recentDocuments[idx])
data = self._recentDocuments[idx]
show = True
self._actionRecentDocuments[idx].setText(text)
self._actionRecentDocuments[idx].setData(data)
self._actionRecentDocuments[idx].setVisible(show)
def onFrozenRightClick(self, point: QPoint):
@Slot(str, str)
def onGekuendigt(mv_id: str, datum: str):
#Model aktualisieren
model.setBis(index.row(), datum)
tv = self._view.tableView
#model = tv.getTableModel()
model = tv.getModel()
index = tv.indexAt(point)
if not index.column() in (model.nameColumnIdx, model.sollColumnIdx):
return
mv_id = model.getId(index.row())
menu = QMenu(tv)
if index.column() == model.nameColumnIdx:
action = QAction("Dieses Mietverhältnis beenden")
action.setData("K")
menu.addAction(action)
menu.addSeparator()
action2 = QAction("Mietverhältnisdaten anzeigen")
action2.setData("A")
menu.addAction(action2)
else:
action = QAction("Nettomiete und NKV anzeigen")
menu.addAction(action)
action = menu.exec_(tv.viewport().mapToGlobal(point))
if action and index.column() == model.nameColumnIdx:
if action.data() == "K":
c = MiniKuendigungsController(self._view)
c.mietverhaeltnisGekuendigt.connect(onGekuendigt)
c.kuendigeMietverhaeltnisUsingMiniDialog(mv_id)
else:
self._showMietverhaeltnis(mv_id, point)
elif action and index.column() == model.sollColumnIdx:
netto, nkv = BusinessLogic.inst().getNettomieteUndNkv(
mv_id, self._currentYear, self._currentCheckMonth)
box = QMessageBox()
box.setWindowTitle("Teile der Bruttomiete")
box.setIcon(QMessageBox.Information)
box.setText("Nettomiete:\t%.2f €\n\n"
"Nebenkosten:\t%.2f €" % (netto, nkv))
box.exec_()
def _sequenceOpened(self, filename, begin, end, streams):
"""
Notifies about an opened sequence.
:param filename: the filename which has been opened
:param begin: timestamp of sequence's first sample
:param end: timestamp of sequence's last sample
:param streams: list of streams in the sequence
:return: None
"""
assertMainThread()
self.beginTime = begin
self.preventSeek = True
self.positionSlider.setRange(0, (end - begin) // 1000000)
self.preventSeek = False
self.beginLabel.setText(self._timeToString(0))
self.endLabel.setText(self._timeToString((end - begin) // 1000000))
self._currentTimestampChanged(begin)
try:
self.browser.blockSignals(True)
self.browser.setActive(filename)
self.browser.scrollTo(filename)
finally:
self.browser.blockSignals(False)
self._selectedStream = None
for a in self.actGroupStream.actions():
logger.debug("Remove stream group action: %s", a.data())
self.actGroupStream.removeAction(a)
for stream in streams:
act = QAction(stream, self.actGroupStream)
act.triggered.connect(
lambda cstream=stream: self.setSelectedStream(cstream))
act.setCheckable(True)
act.setChecked(False)
logger.debug("Add stream group action: %s", act.data())
self.actGroupStreamMenu.addAction(act)
QTimer.singleShot(250, self.scrollToCurrent)
super()._sequenceOpened(filename, begin, end, streams)
def set_unit_type(self, sender: QAction) -> None:
val = UnitType(sender.data())
self._viewer_widget.engine.unit_type = val
self._settings.setValue("unit_type", val)
class AngrWidget(cutter.CutterDockWidget, Ui_AngrWidget):
def __init__(self, parent, action):
try:
super(AngrWidget, self).__init__(parent, action)
register_debugger(cutterDebugger())
self.stateMgr = None
self.main = parent
self.findAddrs = []
self.avoidAddrs = []
self.symAddrs = {}
self.setObjectName("angr_cutter")
self.setWindowTitle("AngrCutter")
self.setupLayout()
self.show()
self.setupActions()
self.startButton.clicked.connect(self.startExplore)
self.applySimButton.clicked.connect(self.applySim)
cutter.core().toggleDebugView.connect(self.debugStateChanged)
cutter.core().refreshAll.connect(self.refreshAll)
except Exception as e:
printMessage(traceback.format_exc(), LogLevel.ERROR)
def refreshAll(self):
# Update baddr in refreshall since it happens after analysis and file changes
self.baddr = int(cutter.cmd("e bin.baddr").strip('\n'), 16)
def setupLayout(self):
self.setupUi(self)
self.viewRegisters = RegistersTable(self)
self.regTableBox.addWidget(self.viewRegisters)
self.startButton.setDisabled(True)
self.stopButton.setDisabled(True)
self.applySimButton.setDisabled(True)
self.memoryCombo.setCurrentIndex(get_memory_type())
self.memoryCombo.currentIndexChanged.connect(self.setMemoryType)
def setupActions(self):
self.findAddrAction = QAction("Angr - find address", self)
self.avoidAddrAction = QAction("Angr - avoid address", self)
self.symAddrAction = QAction("Angr - symbolize address", self)
self.unsetAddrAction = QAction("Angr - unset address", self)
# Disassembly menu actions
menu = self.main.getContextMenuExtensions(cutter.MainWindow.ContextMenuType.Disassembly)
menu.addAction(self.findAddrAction)
menu.addAction(self.avoidAddrAction)
menu.addAction(self.symAddrAction)
menu.addAction(self.unsetAddrAction)
menu.addSeparator()
# Addressable menu actions
menu = self.main.getContextMenuExtensions(cutter.MainWindow.ContextMenuType.Addressable)
menu.addAction(self.symAddrAction)
menu.addAction(self.unsetAddrAction)
menu.addSeparator()
self.findAddrAction.triggered.connect(self.setFindAddr)
self.avoidAddrAction.triggered.connect(self.setAvoidAddr)
self.unsetAddrAction.triggered.connect(self.unsetAddr)
self.symAddrAction.triggered.connect(self.setSymAddr)
def unsetAddr(self):
offset = self.unsetAddrAction.data()
if offset in self.findAddrs:
self.findAddrs.remove(offset)
self.updateFindAddrLine()
if offset in self.avoidAddrs:
self.avoidAddrs.remove(offset)
self.updateAvoidAddrLine()
if offset in self.symAddrs:
del self.symAddrs[offset]
self.updateSymAddrLine()
cutter.cmd("ecH- @ %d" % offset)
def setSymAddr(self):
offset = int(self.symAddrAction.data())
if offset in self.avoidAddrs or offset in self.findAddrs or offset in self.symAddrs:
printMessage("Address %s was already set" %
hex(offset), LogLevel.WARNING)
return
dialog = SymAddrDialog()
dialog.exec_()
size = dialog.getSize()
self.symAddrs[offset] = size
self.updateSymAddrLine()
cutter.cmd("ecHi black @ %d" % offset)
def setFindAddr(self):
offset = int(self.findAddrAction.data())
if offset in self.avoidAddrs or offset in self.findAddrs or offset in self.symAddrs:
printMessage("Address %s was already set" %
hex(offset), LogLevel.WARNING)
return
self.findAddrs.append(offset)
self.updateFindAddrLine()
cutter.cmd("ecHi blue @ %d" % offset)
def setAvoidAddr(self):
offset = int(self.avoidAddrAction.data())
if offset in self.avoidAddrs or offset in self.findAddrs or offset in self.symAddrs:
printMessage("Address %s was already set" %
hex(offset), LogLevel.WARNING)
return
self.avoidAddrs.append(offset)
self.updateAvoidAddrLine()
cutter.cmd("ecHi yellow @ %d" % offset)
def setMemoryType(self):
set_memory_type(self.memoryCombo.currentIndex())
def update(self):
self.updateFindAddrLine()
self.updateAvoidAddrLine()
self.updateSymAddrLine()
def updateFindAddrLine(self):
self.findLine.setText(",".join([hex(addr) for addr in self.findAddrs]))
def updateAvoidAddrLine(self):
self.avoidLine.setText(
",".join([hex(addr) for addr in self.avoidAddrs]))
def updateSymAddrLine(self):
self.symLine.setText(",".join([hex(addr) + '-' + hex(addr + self.symAddrs[addr])
for addr in self.symAddrs]))
def applySim(self):
self.stateMgr.to_dbg(self.simMgr.found[0])
# Synchronize all widgets with the applied memory/register values
cutter.core().refreshAll.emit()
# Return to the previous seek
cutter.cmd("s %d" % cutter.core().getProgramCounterValue())
def startExplore(self):
if len(self.findAddrs) == 0:
printMessage(
"You have to set a find address to explore to", LogLevel.WARNING)
return
self.stateMgr = StateManager()
self.simMgr = self.stateMgr.simulation_manager()
# Configure symbolic memory addresses and registers
for addr in self.symAddrs:
self.stateMgr.sim(addr, self.symAddrs[addr])
for reg in self.viewRegisters.symRegs:
self.stateMgr.sim(
self.stateMgr[reg], self.viewRegisters.symRegs[reg])
# Start exploration
printMessage("Starting exploration with find (%s) and avoid (%s)" %
(self.findAddrs, self.avoidAddrs,), LogLevel.INFO)
printMessage("Symbolics are: " +
str(self.stateMgr.symbolics), LogLevel.INFO)
self.simMgr.explore(find=self.findAddrs, avoid=self.avoidAddrs)
# Attempt to print the results
if len(self.simMgr.found):
printMessage("Found: " + str(self.simMgr.found[0]), LogLevel.INFO)
conc = self.stateMgr.concretize(self.simMgr.found[0])
for addr in conc:
printMessage("0x%x ==> %s" %
(addr, repr(conc[addr])), LogLevel.INFO)
self.applySimButton.setDisabled(False)
else:
printMessage("Failed to find a state", LogLevel.ERROR)
self.applySimButton.setDisabled(True)
# Synchronize displays
cutter.core().refreshAll.emit()
# Return to the previous seek
cutter.cmd("s %d" % cutter.core().getProgramCounterValue())
def debugStateChanged(self):
# Calculate the diff based on the previous baddr
baddr = int(cutter.cmd("e bin.baddr").strip('\n'), 16)
diff = baddr - self.baddr
self.baddr = baddr
if cutter.core().currentlyDebugging:
disableUi = False
else:
del self.stateMgr
self.stateMgr = None
disableUi = True
# applySim can be enabled only after startExplore
self.applySimButton.setDisabled(True)
# Enable exploration action when in debug mode
self.startButton.setDisabled(disableUi)
self.stopButton.setDisabled(disableUi)
# Rebase addresses
tmp = []
for addr in self.findAddrs:
tmp.append(addr + diff)
self.findAddrs = tmp
tmp = []
for addr in self.avoidAddrs:
tmp.append(addr + diff)
self.avoidAddrs = tmp
tmp = {}
for addr in self.symAddrs:
tmp[addr + diff] = self.symAddrs[addr]
self.symAddrs = tmp
self.update()
