def _showBannedFunctions(self):
"""
Points to functions banned by Microsoft being used.
"""
self._console_output("Looking for banned functions...")
deep_search_f = self.config.deep_dangerous_functions
if deep_search_f:
self._console_output("Performing a deep search (based on function name)")
banned_refs_dict = self.vd.find_banned_functions(deep_search_f)
if not banned_refs_dict:
self._console_output("[!] No banned functions found", err = True)
return
self.tree_label.setText("Functions banned by Microsoft")
self.tree.clear()
self.tree.setHeaderLabels(("Banned function", "References", "Name"))
for f_name, refs in banned_refs_dict.iteritems():
bf_item = QTreeWidgetItem(self.tree)
bf_item.setText(0, f_name)
for ref_addr in refs:
ref_item = QTreeWidgetItem(bf_item)
ref_item.setText(1, "%x" %ref_addr)
ref_name = misc.get_function_name(ref_addr)
ref_item.setText(2, ref_name)
# Display all items expanded initially
self.tree.expandAll()
def _init_widgets(self):
self.clear()
if self._simgr is None:
return
for stash_name, stash in self._simgr.stashes.iteritems():
if not stash and stash_name not in ('active', 'deadended',
'avoided'):
continue
item = QTreeWidgetItem(self,
["%s (%d)" % (stash_name, len(stash))])
for state in stash:
subitem = QTreeWidgetItem(item, [str(state)])
item.addChild(subitem)
self.addTopLevelItem(item)
# errored states
if self._simgr.errored:
item = QTreeWidgetItem(
self, ["%s (%d)" % ('errored', len(self._simgr.errored))])
for state in self._simgr.errored:
subitem = QTreeWidgetItem(item, [str(state)])
item.addChild(subitem)
self.addTopLevelItem(item)
def fill_item(self,item, value):
item.setExpanded(True)
if type(value) is dict:
for key, val in sorted(value.iteritems()):
child = QTreeWidgetItem()
x = "{0:.3f}".format(key)
# x = key
child.setText(0, unicode(x))
child.setFlags(Qt.ItemIsEnabled)
item.addChild(child)
self.fill_item(child, val)
elif type(value) is list:
for val in value:
child = QTreeWidgetItem()
item.addChild(child)
if type(val) is dict:
child.setText(0, '[dict]')
self.fill_item(child, val)
elif type(val) is list:
child.setText(0, '[list]')
self.fill_item(child, val)
else:
child.setText(0, str(value.index(val)))
child.setExpanded(True)
else:
print 'hi'
child = QTreeWidgetItem()
child.setText(0, unicode(value))
item.addChild(child)
def OnCreate(self, form):
self.setupUi(self)
self.connect(self.add_trace_button, QtCore.SIGNAL("clicked()"),
self.load_trace)
self.connect(self.disassemble_button, QtCore.SIGNAL("clicked()"),
self.disassemble_from_trace)
self.connect(self.colorize_button, QtCore.SIGNAL("clicked()"),
self.colorize_trace)
self.connect(self.heatmap_button, QtCore.SIGNAL("clicked()"),
self.heatmap_trace)
self.connect(self.dump_button, QtCore.SIGNAL("clicked()"),
self.dump_trace)
self.connect(self.refresh_button, QtCore.SIGNAL("clicked()"),
self.refresh_trace_view)
self.connect(self.traces_tab, QtCore.SIGNAL('currentChanged(int)'),
self.trace_switch)
self.connect(self.traces_tab, QtCore.SIGNAL('tabCloseRequested(int)'),
self.unload_trace)
self.loading_stat.setVisible(False)
self.progressbar_loading.setVisible(False)
self.traces_tab.setTabsClosable(True)
#self.reads_view.headerItem().setHidden(True)
#self.writes_view.headerItem().setHidden(True)
self.reads_view.setHeaderItem(QTreeWidgetItem(["name", "value"]))
self.writes_view.setHeaderItem(QTreeWidgetItem(["name", "value"]))
def _showDwordCompares(self):
"""
Inspects the *whole* binary looking for comparisons between
global dwords and immediate values. These usually contain error
codes or alike and appear constantly through the code.
"""
self._console_output("Looking for Dword compares...")
self.tree_label.setText("Dword immediate compares")
dw_dict = self.ba.get_dword_compares()
# Fill the tree with items
self.tree.setHeaderLabels(("Dword", "Values", "Address"))
for dw, values in dw_dict.iteritems():
dw_item = QTreeWidgetItem(self.tree)
dw_item.setText(0, dw)
for value, addr in values:
value_item = QTreeWidgetItem(dw_item)
value_item.setText(1, value)
value_item.setText(2, "0x%x" % addr)
# Display all items expanded initially
self.tree.expandAll()
def buildEdgeList(self):
''' populate the ui tree with the edges that can be extended'''
self.edgeList = []
treeExists = False
if self.edges_TW.topLevelItem(0):
treeExists = True
parentItem = self.edges_TW.topLevelItem(0)
else:
self.edges_TW.clear()
parentItem = QTreeWidgetItem()
faceName = self.face_LE.text()
parentItem.setText(0, faceName)
self.edges_TW.addTopLevelItem(parentItem)
self.edges_TW.expandItem(parentItem)
if not treeExists:
for edgeNum in self.helperFace.ExtendableEdges:
###### populate the edge tree ######
edgeItem = QTreeWidgetItem()
edgeItem.setText(0, str("Edge" + str(edgeNum)))
checked = QtCore.Qt.Unchecked
if edgeNum in self.helperFace.CheckedEdges:
checked = QtCore.Qt.Checked
edgeItem.setCheckState(0, checked)
parentItem.addChild(edgeItem)
self.loadTools()
def update_instruction_informations(self, new_item, old_item):
index = self.traces_tab.currentIndex()
try:
table = self.index_map[index]
trace = self.core.traces[self.id_map[index]]
offset = int(table.item(new_item.row(), 0).text())
inst = trace.instrs[offset]
#=== Gui stuff
self.reads_view.clear()
self.writes_view.clear()
self.additional_infos.clear()
for r_w, name, value in inst.registers:
val_s = hex(value)[:-1] if hex(value).endswith('L') else hex(
value)
infos = [name, val_s]
widget = QTreeWidgetItem(infos)
if r_w == "R":
self.reads_view.addTopLevelItem(widget)
else:
self.writes_view.addTopLevelItem(widget)
for r_w, addr, value in inst.memories:
infos = [
"@[%x]" % addr,
"".join("{:02x}".format(ord(c)) for c in value)
]
widget = QTreeWidgetItem(infos)
if r_w == "R":
self.reads_view.addTopLevelItem(widget)
else:
self.writes_view.addTopLevelItem(widget)
for i in range(self.reads_view.topLevelItemCount()):
self.reads_view.resizeColumnToContents(i)
for i in range(self.writes_view.topLevelItemCount()):
self.writes_view.resizeColumnToContents(i)
if inst.nextaddr is not None:
self.additional_infos.setHtml("Next addr:<bold>" +
hex(inst.nextaddr)[:-1] +
"</bold>")
if inst.wave is not None:
self.additional_infos.append("Wave: " + str(inst.wave))
if inst.syscall is not None:
self.additional_infos.append("Syscall:" + str(inst.syscall.id))
if inst.libcall is not None:
c = inst.libcall
s = "Libcall:<span style='color:blue;'>" + str(
c.func_name) + "</span>"
s += "<ul><li>at:" + hex(c.func_addr)[:-1] + "</li>"
s += "<li>traced: <span style='color:" + (
"blue" if c.is_traced else "red") + ";'>" + str(
c.is_traced) + "</span></li></ul>"
self.additional_infos.append(s)
if inst.comment is not None:
self.additional_infos.append("Comment:" + inst.comment)
except ValueError:
pass
except KeyError:
pass
def fill_item(self, item, value): #recursively fills the tree
item.setExpanded(True)
for key, val in sorted(value.iteritems()): #tilts
child = QTreeWidgetItem()
child.setText(0, unicode(key))
child.setFlags(Qt.ItemIsEnabled)
item.addChild(child)
for keykey in sorted(val.keys()): #imgIDs
childchild = QTreeWidgetItem()
child.addChild(childchild)
childchild.setText(0, str(keykey))
child.setExpanded(True)
childchild.setExpanded(True)
def add_to_tree(self):
if self.mysql.do:
self.nDataBase = self.mysql.getDataBase()
for i in self.nDataBase:
item_m = QTreeWidgetItem(self)
item_m.setStatusTip(0, 'main')
item_m.setText(0, "%s" % i)
if i in self.li:
item_m.setExpanded(True)
self.table = self.mysql.getTables(i)
for j in self.table:
item_c = QTreeWidgetItem(item_m)
item_c.setStatusTip(0, i)
item_c.setText(0, "%s" % j)
def __make_item(self, name, type_name):
item = QTreeWidgetItem(None, [name, type_name])
item.setChildIndicatorPolicy(QTreeWidgetItem.ShowIndicator)
if type_name == UI.ACTION_GROUP:
item.setIcon(0,
QtGui.QIcon(Options.assets_path + "folder_16x16.png"))
return item
def _addMachineToDeployedList(self, ip_address, comment, host):
'''Adds the given machine to the list of the user deployed ones'''
itm = QTreeWidgetItem()
itm.setText(0, ip_address)
itm.setText(1, comment)
itm.setText(2, host)
self._mywindow.tw_deployed.addTopLevelItem(itm)
def renderCorpEvent(self, corporateEventPositionDictAsset):
self.clearTables()
self.treeCorporateEvent.setColumnCount(3)
self.treeCorporateEvent.setHeaderLabels(self.columnListCorporateEvent)
for key, cep in corporateEventPositionDictAsset.items():
l1 = QTreeWidgetItem(
[key, str(cep.accGrossAmount),
str(cep.accNetAmount)])
for ce in cep.corporateEventList:
l1_child = QTreeWidgetItem([
None,
str(ce.grossAmount),
str(ce.netAmount),
str(ce.paymentDate)
])
l1.addChild(l1_child)
self.treeCorporateEvent.addTopLevelItem(l1)
def _init_widgets(self):
self.clear()
if self._pathgroup is None:
return
for stash_name, stash in self._pathgroup.stashes.iteritems():
if not stash and stash_name not in ('active', 'deadended', 'avoided'):
continue
item = QTreeWidgetItem(self, [ "%s (%d)" % (stash_name, len(stash)) ])
for path in stash:
subitem = QTreeWidgetItem(item, [ str(path) ])
item.addChild(subitem)
self.addTopLevelItem(item)
def _addRunningVmToList(self, lst):
'''adds a vm to the running vm list from a list of strings'''
#FIXME: use a dict
itm = QTreeWidgetItem()
itm.setText(0, lst[0])
itm.setText(1, lst[1])
itm.setText(2, lst[2])
itm.setText(3, lst[3])
itm.setText(4, lst[4])
itm.setText(5, lst[5])
self._mywindow.tw_running_vms.addTopLevelItem(itm)
def update(self):
"""
Updates listed publishers, newspapers and subscribers
"""
self.view.publishers.clear()
self.view.subscribers.clear()
for publisher in self.publishers.values():
p_widget = QTreeWidgetItem()
p_widget.setText(0, publisher.name)
for newspaper in publisher.newspapers:
n_widget = QTreeWidgetItem(p_widget)
n_widget.setText(0, newspaper)
self.view.publishers.addTopLevelItem(p_widget)
for subscriber in self.subscribers:
s_widget = QTreeWidgetItem()
s_widget.setText(0, subscriber)
self.view.subscribers.addTopLevelItem(s_widget)
def testWidgetIterator(self):
treeWidget = QTreeWidget()
treeWidget.setColumnCount(1)
items = []
for i in range(10):
items.append(QTreeWidgetItem(None, ['item: %d' % i]))
treeWidget.insertTopLevelItems(0, items)
index = 0
for it in QTreeWidgetItemIterator(treeWidget):
self.assertEqual(it.value().text(0), 'item: %d' % index)
index += 1
def cmd_loadList(self):
self.treeWidget.clear()
sels = pymel.core.ls(sl=1, type='transform')
data = []
for sel in sels:
widgetItem = QTreeWidgetItem(self.treeWidget)
widgetItem.setText(0, sel.name())
widgetItem.setText(1, sel.nodeName().split('_')[-1])
widgetItem.setFlags(widgetItem.flags() | QtCore.Qt.ItemIsEditable)
data.append([widgetItem.text(0), widgetItem.text(1)])
def _refresh_value_tree(self, directory_info):
info = sorted(directory_info, key=lambda x: x.total_size, reverse=True)
# Clear
for _ in range(self.value_tree.topLevelItemCount()):
self.value_tree.takeTopLevelItem(0)
# Add
for item in info:
tree_widget = QTreeWidgetItem()
tree_widget.setText(0, item.part_path)
tree_widget.setText(1, self._get_size(item.total_size))
self.value_tree.addTopLevelItem(tree_widget)
def addGroup(self, name, title):
"""
Add a new group.
``name`` and ``title`` are unicode strings. ``name`` is used to
identify this group, ``title`` is displayed to the user.
"""
if name in self._groups:
raise ValueError('Duplicate group')
self._groups[name] = QTreeWidgetItem([title])
self.addTopLevelItem(self._groups[name])
# expand groups initially
self.setGroupExpanded(name, True)
def addOption(self, group_name, name, title):
"""
Add an option to a group.
All arguments are unicode strings. ``group_name`` is the name of the
group this option is added to. ``name`` is the name of the option
itself, ``title`` is displayed to the user.
"""
if name in self._options:
raise ValueError('Duplicate option')
group_item = self._groups[group_name]
self._options[name] = QTreeWidgetItem(group_item, [title])
# uncheck options initially
self.setOptionChecked(name, False)
def _populateTree(self):
self.pushupsListWidget.clear()
self.pushupsListWidget.setColumnCount(4)
self.pushupsListWidget.setHeaderLabels([
"Date", "TotalPushups", "Series", "Repetitions",
"Average Heart Rate"
])
self.pushupsListWidget.setSortingEnabled(True)
self.pushupsListWidget.setColumnWidth(0, 180)
self.pushupsListWidget.setColumnWidth(4, 150)
pushupDict = self._getPushupDictionary()
for it, dayOfExercise in enumerate(sorted(pushupDict.keys())):
dateItem = QTreeWidgetItem()
dayLabel = dayOfExercise.strftime("%Y/%m/%d")
dateItem.setText(0, "\n" + dayLabel + "\nDay : " + str(it))
self.pushupsListWidget.addTopLevelItem(dateItem)
totalPushups = 0
for pushup in pushupDict[dayOfExercise]:
pushupItem = QTreeWidgetItem()
pushupItem.setText(2, "#" + str(pushup._series))
pushupItem.setText(3, str(pushup._repetitions))
pushupItem.setText(4, str(pushup._averageHeartRate))
pushupItem.setData(0, Qt.UserRole, pushup)
totalPushups = totalPushups + pushup._repetitions
dateItem.addChild(pushupItem)
dateItem.setText(1, str(totalPushups))
def testCase(self):
treeWidget = QTreeWidget()
treeWidget.setColumnCount(1)
items = []
for i in range(10):
items.append(QTreeWidgetItem(None, ["item: %i" % i]))
treeWidget.insertTopLevelItems(0, items);
_iter = QTreeWidgetItemIterator(treeWidget)
index = 0
while(_iter.value()):
item = _iter.value()
self.assert_(item is items[index])
index += 1
_iter += 1
def readData(self, *args):
data = super(Widget_objectList,
self).readData(Widget_objectList.path_uiInfo)
if not type(data) == dict: return
self.treeWidget.clear()
keys = data.keys()
keys.sort()
for key in keys:
try:
nodeName, attrName = data[key]
except:
return
widgetItem = QTreeWidgetItem(self.treeWidget)
widgetItem.setText(0, nodeName)
widgetItem.setText(1, attrName)
widgetItem.setFlags(widgetItem.flags() | QtCore.Qt.ItemIsEditable)
def _refresh_key_tree(self, directory_info, ignore_list=None):
info = LabelInfo(make_dictionary_by_classification(directory_info, ignore_list))
# Clear
for _ in range(self.key_tree.topLevelItemCount()):
self.key_tree.takeTopLevelItem(0)
# Add
for k, v in info.sort_dictionary:
tree_widget = QTreeWidgetItem()
tree_widget.setText(0, k)
total_size = 0
for child in v['children']:
total_size += child.total_size
tree_widget.setText(1, self._get_size(v[constant.sort_size_name]))
self.key_tree.addTopLevelItem(tree_widget)
self._last_info = info
def loadControllers(self):
self.treeWidget.clear()
sels = pymel.core.ls( sl=1 )
currentParent = self.treeWidget
self.items = []
for sel in sels:
widgetItem = QTreeWidgetItem( currentParent )
widgetItem.realObject = sel
widgetItem.setText( 0, sel.name() )
if isinstance( currentParent, QTreeWidgetItem ):
currentParent.setExpanded( True )
currentParent = widgetItem
self.items.append( sel.name() )
self.saveInfo()
def add_set(self, iterable, title=None):
"""
Adding the given iterable to the list with a first Separator object with given title
:param iterable: list of item's attributes
:param title: Separator's name
"""
if len(iterable):
# if title is given we first add a Separator item to indicate coming list title
if title:
self.WL_attributes.addTopLevelItem(
QTreeWidget_Separator(title))
items = []
for attr in sorted(iterable):
item = QTreeWidgetItem([attr])
# assigning the attribute itself inside a custom parameter
item.attribute = attr
items.append(item)
# finally adding all the items to the list
self.WL_attributes.addTopLevelItems(items)
def updateStorage(self):
self.storageTreeWidget.clear()
vols = self.sti.logicalDrives()
for volName in vols:
volType = self.sti.typeForDrive(volName)
if volType == QSystemStorageInfo.InternalDrive:
typeName = "Internal"
elif volType == QSystemStorageInfo.RemovableDrive:
typeName = "Removable"
elif volType == QSystemStorageInfo.CdromDrive:
typeName = "Cdrom"
elif volType == QSystemStorageInfo.RemoteDrive:
typeName = "Network"
items = []
items.append(volName)
items.append(typeName)
items.append(str(self.sti.totalDiskSpace(volName)))
items.append(str(self.sti.availableDiskSpace(volName)))
item = QTreeWidgetItem(items)
self.storageTreeWidget.addTopLevelItem(item)
def import_from_text_file(self):
arquivo_Caminho = QFileDialog.getOpenFileName(
None, "Select txt file", '/', "(*.txt);; All Files (*.*)", None)[0]
filename = arquivo_Caminho
self.f = open(filename)
reader = csv.reader(self.f, delimiter='\t')
linhas = [linha for linha in reader]
for i in linhas:
if len(i) == 0:
continue
else:
print i
a = QTreeWidgetItem(self.ui.treeWidget)
a.setText(0, str(i[0]))
a.setText(1, str(i[1]))
a.setText(2, str(i[2]))
a.setText(3, str(i[3]))
def loadInfo(self):
data = BaseCommands.readData( self.uiInfoPath )
if not data.has_key( 'controllers' ): return None
controllerList = data[ 'controllers' ]
controllers = []
for controller in controllerList:
if not pymel.core.ls( controller ): continue
controllers.append( pymel.core.ls( controller )[0] )
self.treeWidget.clear()
currentParent = self.treeWidget
self.items = []
for sel in controllers:
widgetItem = QTreeWidgetItem( currentParent )
widgetItem.realObject = sel
widgetItem.setText( 0, sel.name() )
if isinstance( currentParent, QTreeWidgetItem ):
currentParent.setExpanded( True )
currentParent = widgetItem
self.items.append( sel.name() )
def update(self):
items = []
playerx, playery = 0, 0
for objid, obj in self.worldviewer.world_objects.items():
if "Object.ScriptedObject.Character" in obj['_types']:
playerx = obj['loc']['x']
playery = obj['loc']['y']
break
for objid, obj in self.worldviewer.world_objects.items():
name = obj['name']
try:
locx = obj['loc']['x']
except KeyError:
continue
locy = obj['loc']['y']
locz = obj['loc']['z']
resource = obj['resource']
last_modified = datetime.datetime.fromtimestamp(
int(str(obj['last_modified']['$date'])[:-3]))
row = self.objects_tree.findItems(objid, Qt.MatchExactly, column=0)
if row:
# Update it if it exists already
item = row[0]
if not row:
# If Item does not exist in the tree widget already, make a new one.
item = QTreeWidgetItem(self.objects_tree)
items.append(item)
for i, param in enumerate(
(objid, name, (locx, locy, locz), resource, last_modified,
"%04d" % euclidian(locx, locy, playerx, playery))):
item.setText(i, str(param))
if items:
self.objects_tree.insertTopLevelItems(0, items)
