def render_full(self, target, **options):
if target == []:
return text.Cell(u"")
result = []
for i, item in enumerate(target):
if len(target) > 1:
result.append(self.table.get_row("- %s:" % i))
result.append(self.table.get_row(item))
return text.StackedCell(*result, **options)
def render_row(self, target, **options):
width = options.pop("width", None)
result = []
for item in target:
object_renderer = self.ForTarget(item, self.renderer)(
session=self.session, renderer=self.renderer)
options["wrap"] = False
cell = object_renderer.render_row(item, **options)
result.append("\\n".join(cell.lines))
return text.Cell(", ".join(result), width=width)
def render_row(self, target, **options):
if self.output_style == "full":
return self.table.get_row(
target.obj_offset, target.name, target.FullPath, target.pid,
target.InheritedFromUniqueProcessId)
elif self.output_style == "concise":
return self.table.get_row(target.obj_offset, target.name,
target.pid)
else:
return text.Cell(u"%s %s (%d)" % (
self.format_address(target.obj_offset),
target.name, target.pid))
def render_full(self, target, **_):
if target.mode == "AMD64":
format_string = "%0#14x %s"
else:
format_string = "%0#10x %s"
result = []
for instruction in target.disassemble():
result.append(format_string % (instruction.address,
instruction.text))
return text.Cell("\n".join(result))
def render_row(self, target, **options):
result = []
for item in target:
object_renderer = self.ForTarget(item, self.renderer)(
session=self.session, renderer=self.renderer)
result.append(object_renderer.render_row(item, **options))
result.append(text.Cell(","))
if result:
result.pop(-1)
return text.JoinedCell(*result)
def render_row(self, item, hex_width=None, **options):
if hex_width is None:
hex_width = self.session.GetParameter("hexdump_width", 8)
data = item.value
highlights = item.highlights or []
hex_highlights = []
for x, y, f, b in highlights:
hex_highlights.append((3 * x, 3 * y, f, b))
hexcell = text.Cell(width=hex_width * 3,
highlights=hex_highlights,
colorizer=self.renderer.colorizer)
datacell = text.Cell(width=hex_width,
highlights=highlights,
colorizer=self.renderer.colorizer)
for _, hexdata, translated_data in utils.Hexdump(data,
width=hex_width):
hexcell.append_line(hexdata)
datacell.append_line("".join(translated_data))
return text.JoinedCell(hexcell, datacell)
def render_compact(self, target, **_):
result = []
for name in sorted(target.members):
if name.endswith("Enum"):
continue
try:
attribute = getattr(target, name)
if attribute.v():
result.append("%s: %s" % (name, attribute))
except AttributeError:
pass
return text.Cell(", ".join(result))
def render_row(self, target, **_):
column_names = [x["name"] for x in target.fields]
table = text.TextTable(columns=target.fields,
renderer=self.renderer,
session=self.session)
if not target.results:
return text.Cell("")
result = [
text.JoinedCell(*[text.Cell(x) for x in column_names]),
text.JoinedCell(*[text.Cell("-" * len(x)) for x in column_names])
]
for row in target.results:
ordered_row = []
for column in column_names:
ordered_row.append(row.get(column))
result.append(table.get_row(*ordered_row))
result = text.StackedCell(*result)
return result
def render_full(self, target, width=None, **_):
table = text.TextTable(
columns=[
dict(name="Address", style="address"),
dict(name="OpCode", width=16),
dict(name="Op", width=width)
],
renderer=self.renderer,
session=self.session)
result = []
for instruction in target.disassemble():
result.append(unicode(table.get_row(
instruction.address, instruction.hexbytes, instruction.text)))
return text.Cell("\n".join(result))
def render_row(self, target, **_):
if target.flag:
prefix = "+"
else:
prefix = "-"
template = "{prefix} {component}"
if target.attribute:
template += "/{attribute}"
if target.value:
template += "={value}"
return text.Cell(template.format(component=target.component,
prefix=prefix,
attribute=target.attribute,
value=target.value))
def render_full(self, target, **_):
"""Full render of a struct outputs every field."""
result = repr(target) + "\n"
width_name = 0
fields = []
# Print all the fields sorted by offset within the struct.
for k in target.members:
width_name = max(width_name, len(k))
obj = getattr(target, k)
if obj == None:
obj = target.m(k)
fields.append(
(getattr(obj, "obj_offset", target.obj_offset) -
target.obj_offset, k, utils.SmartUnicode(repr(obj))))
fields.sort()
result = result + u"\n".join(
[u" 0x%02X %s%s %s" % (offset, k, " " * (width_name - len(k)), v)
for offset, k, v in fields]) + "\n"
return text.Cell(result)
def render_full(self, target, **options):
result = text.Cell(unicode(target.v()), **options)
return result
def render_address(self, target, **options):
return text.Cell(self.format_address(target.obj_offset, **options))
def render_compact(self, target, **_):
return text.Cell(target.name)
def render_repr(self, target, **_):
"""Explicitly just render the repr."""
return text.Cell(repr(target))
def render_full(self, target, **_):
return text.Cell(repr(target))
def render_full(self, target, **options):
return text.Cell("(void *) %s" %
self.format_address(target.v(), **options))
def render_compact(self, target, **_):
return text.Cell(repr(target))
def render_compact(self, target, **options):
return text.Cell(
"(%s *) %s" %
(target.target, self.format_address(target.v(), **options)))
def render_row(self, target, **_):
return text.Cell(target.strftime("%Y-%m-%d %H:%M:%S%z"))
def render_address(self, target, width=None, **options):
return text.Cell(self.format_address(target.v(), **options),
width=width)
def render_row(self, target, **_):
return text.Cell("." * int(target))
def render_row(self, target, **_):
return text.Cell("-")
def render_full(self, target, **_):
return text.Cell(target.address)
def render_compact(self, target, width=None, **_):
return text.Cell(unicode(target), width=width)
def render_value(self, target, **_):
return text.Cell(unicode(target.v()))
def render_full(self, target, **_):
return text.Cell(utils.SmartUnicode(target).split("\x00")[0] or u"")
def render_row(self, target, **_):
return text.Cell(
self.formatter.format("{0:s} Pid: {1:s} (@{2:#x})", target.name,
target.pid, target))
def render_full(self, target, **_):
color = "GREEN" if target else "RED"
return text.Cell(value=unicode(target),
highlights=[(0, -1, color, None)])
def render_compact(self, target, **_):
return text.Cell("{%s}" % ", ".join([repr(x) for x in target]))
