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]))