def registers(self):
if hasattr(self.of.cpu, "registers"):
t = vltable()
t.rowparams["sep"] = ': '
for _r in self.of.cpu.registers:
if _r.etype & regtype.FLAGS:
if _r._is_slc:
sta, sto = _r.pos, _r.pos + _r.size
_r = _r.x
else:
sta, sto = 0, _r.size
val = [(Token.Literal, '[ ')]
for pos, sz in _r._subrefs:
if (sta <= pos < sto) and (sz < (sto - sta)):
_s = _r[pos:pos + sz]
val.extend(_s.toks())
val.append((Token.Literal, ':'))
val.extend(self.of.state(_s).toks())
val.append((Token.Literal, ' | '))
val.pop()
val.append((Token.Literal, ' ]'))
elif not _r.etype & regtype.OTHER:
val = self.of.state(_r).toks()
else:
val = None
if val:
t.addrow(_r.toks() + [(Token.Column, "")] + val)
else:
t = ""
return t
def pp(self, **kargs):
t = vltable()
t.rowparams['sep'] = ' <- '
for (l, v) in self:
if l._is_reg: v = v[0:v.size]
lv = (l.toks(**kargs) + [(render.Token.Column, '')] +
v.toks(**kargs))
t.addrow(lv)
if t.colsize[0] > 18: t.colsize[0] = 18
if t.colsize[1] > 58: t.colsize[1] = 58
return str(t)
def _vltable(self, **kargs):
T = vltable(**kargs)
for i in self.of.instr:
T.addrow(self.instr(i))
if conf.Code.bytecode:
pad = conf.Code.padding
T.colsize[1] += pad
if conf.Code.header:
th = " block %s ".center(32, icons.hor)
T.header = (th % self.of.address).ljust(T.width, icons.hor)
if conf.Code.footer:
T.footer = icons.hor * T.width
return T
def title(self, more=None):
t = vltable()
t.rowparams["sep"] = icons.tri
t.addrow([(Token.Column, ''), (Token.String, self.of.bin.filename),
(Token.Column, ''),
(Token.Address, self.of.bin.__class__.__name__),
(Token.Column, ''), (Token.Address, self.of.__module__)])
if more:
r = t.rows[0]
for x in more:
r.toks.append((Token.Column, ''))
r.toks.append(x)
t.update()
return t
def checksec(self):
if hasattr(self.of.bin, "checksec"):
t = vltable()
t.rowparams["sep"] = icons.sep
s = self.of.bin.checksec()
tokattr = lambda v: Token.Good if v else Token.Alert
r = []
for k, v in s.items():
r.append((tokattr(v), "%s: %s" % (k, v)))
r.append((Token.Column, ""))
r.pop()
t.addrow(r)
else:
t = ""
return t
def title(self, more=None):
t = vltable()
t.rowparams["sep"] = icons.tri
t.addrow([(Token.Column, ''), (Token.String, self.of.bin.filename),
(Token.Column, ''),
(Token.Address, self.of.bin.__class__.__name__),
(Token.Column, ''), (Token.Address, self.of.__module__)])
if not more and hasattr(self.of, "title_info"):
more = [(Token.Alert, x) for x in self.of.title_info()]
if more:
r = t.rows[0]
for x in more:
r.cols[-1].append((Token.Column, ''))
r.cols.append([x])
t.update()
return t
def _vltable(self, **kargs):
"""
Returns the vltable from instructions' of the block with additional
header/footer, address and possibly bytecode.
"""
T = vltable(**kargs)
for i in self.of.instr:
T.addrow(self.instr(i))
if conf.Code.bytecode:
pad = conf.Code.padding
T.colsize[1] += pad
if conf.Code.header:
th = " block %s ".center(32, icons.hor)
T.header = (th % self.of.address).ljust(T.width, icons.hor)
if conf.Code.footer:
T.footer = icons.hor * T.width
return T
def _vltable(self, **kargs):
t = vltable(**kargs)
t.rowparams['sep'] = ' <- '
for (l, v) in self.of:
if l._is_reg:
if l.type == regtype.FLAGS:
t.addrow(l.toks(**kargs) + [(Token.Literal, ':')])
for pos, sz in l._subrefs:
t.addrow([(Token.Literal, '| ')] +
l[pos:pos + sz].toks(**kargs) +
[(Token.Column, u'')] +
v[pos:pos + sz].toks(**kargs))
continue
v = v[0:v.size]
lv = (l.toks(**kargs) + [(Token.Column, u'')] + v.toks(**kargs))
t.addrow(lv)
return t
def _vltable(self, **kargs):
t = vltable(**kargs)
t.rowparams["sep"] = " <- "
for (l, v) in self.of:
if l._is_reg:
if l.type == regtype.FLAGS:
t.addrow(l.toks(**kargs) + [(Token.Literal, ":")])
for pos, sz in l._subrefs:
t.addrow([(Token.Literal, "| ")] +
l[pos:pos + sz].toks(**kargs) +
[(Token.Column, "")] +
v[pos:pos + sz].toks(**kargs))
continue
v = v[0:v.size]
lv = l.toks(**kargs) + [(Token.Column, "")] + v.toks(**kargs)
t.addrow(lv)
return t
def _vltable(self, **kargs):
t = vltable(**kargs)
t.rowparams["sep"] = icons.sep
for k, z in self.of._zones.items():
if k is None:
a = ""
else:
a = str(k)
for o in z._map:
lv = []
lv.append((Token.Address, "%s%+08x" % (a, o.vaddr)))
lv.append((Token.Column, ""))
data = str(o.data)
lv.append((Token.Literal, data))
lv.append((Token.Column, ""))
lv.append((Token.Address, ".%+08x" % (o.end)))
t.addrow(lv)
t.addrow((Token.Memory, icons.hor * 8))
return t
def frame_code(self):
t = []
t.append(self.line("code"))
here = self.of.task.state(self.of.pc)
T = vltable()
flavor = None
blk = self.of.sa.iterblocks(here)
try:
b = next(blk)
except StopIteration:
b = None
logger.warning("no block at address %s" % here)
else:
blk.close()
if b is not None:
delay_slot = False
for i in b.instr:
if (i.address == here):
flavor = 'Mark'
if i.misc.get('delayed', False):
delay_slot = True
elif delay_slot:
flavor = 'Mark'
delay_slot = False
else:
flavor = None
T.addrow(blockView.instr(i, flavor))
for index in range(1, conf.Code.hist + 1):
try:
i = self.of.hist[-index]
except IndexError:
break
if (here - i.address) > i.length:
T.rows.insert(0, tokenrow([(Token.Literal, '|')]))
if i.address < here:
T.rows.insert(0, tokenrow(blockView.instr(i)))
here = i.address
T = self.of.task.view.code(T)
T.header = T.footer = ""
rest = self.term.width - T.width
T.addcolsize(-1, rest)
t.append(str(T))
return t
def memory(self,start,nbl=1,nbc=1,w=None):
t = vltable()
t.rowparams["sep"] = ' '
aw = self.of.cpu.PC().size
if w is None:
w=aw
if isinstance(start,int):
start = self.of.cpu.cst(start,size=aw)
if hasattr(start,'etype'):
cur = self.of.cpu.mem(start,size=w)
for i in range(nbl):
r = cur.a.toks() + [(Token.Column,""), (Token.Literal, icons.ver+" ")]
for j in range(nbc):
r.extend(self.of.state(cur).toks())
r.append((Token.Column, ""))
cur.a.disp += w//8
r.pop()
t.addrow(r)
return t
def _vltable(self, **kargs):
T = vltable(**kargs)
n = len(self.of.instr)
for i in self.of.instr:
ins2 = i.toks()
if isinstance(ins2, str): ins2 = [(Token.Literal, ins2)]
ins = [(Token.Address, '{:<10}'.format(i.address)),
(Token.Column, ''),
(Token.Literal, "'%s'" % (i.bytes.encode('hex'))),
(Token.Column, '')]
T.addrow(ins + ins2)
if conf.getboolean('block', 'bytecode'):
pad = conf.getint('block', 'padding') or 0
T.colsize[1] += pad
if conf.getboolean('block', 'header'):
T.header = ('# --- block %s ---' % self.of.name).ljust(
T.width, '-')
if conf.getboolean('block', 'footer'):
T.footer = '-' * T.width
return T
def _vltable(self, **kargs):
T = vltable(**kargs)
n = len(self.of.instr)
for i in self.of.instr:
ins2 = i.toks()
if isinstance(ins2, str): ins2 = [(Token.Literal, ins2)]
b = [u"%02x" % x for x in bytes(i.bytes)]
ins = [(Token.Address, u'{:<20}'.format(str(i.address))),
(Token.Column, u''),
(Token.Literal, u"'%s'" % (u''.join(b))),
(Token.Column, u'')]
T.addrow(ins + ins2)
if conf.Code.bytecode:
pad = conf.Code.padding
T.colsize[1] += pad
if conf.Code.header:
th = u'# --- block %s ---'
T.header = (th % self.of.address).ljust(T.width, '-')
if conf.Code.footer:
T.footer = u'-' * T.width
return T
def hexdump(self, cur=None, nbb=None, nbl=None):
if cur is None: cur = self.cur
if nbb is None: nbb = self.nbb
if nbl is None: nbl = self.nbl
self.cur = cur
self.nbb = nbb
self.nbl = nbl
t = vltable()
t.rowparams["sep"] = icons.sep
for l in range(self.nbl):
r = [(Token.Address, "%08x" % self.cur), (Token.Column, "")]
data = self.of[self.cur:self.cur + self.nbb]
s = " ".join(["%02x" % d for d in data])
# add extra space
s = s[0:23] + " " + s[23:]
r.append((Token.Literal, s))
r.append((Token.Column, ""))
s = "".join([chr(x) if 32 <= x <= 127 else '.' for x in data])
r.append((Token.Literal, s))
self.cur += self.nbb
t.addrow(r)
return t
def _vltable(self, **kargs):
T = vltable(**kargs)
for i in self.of.instr:
ins2 = i.toks()
if isinstance(ins2, str):
ins2 = [(Token.Literal, ins2)]
b = ["%02x" % x for x in bytes(i.bytes)]
ins = [
(Token.Address, "{:<20}".format(str(i.address))),
(Token.Column, ""),
(Token.Literal, "'%s'" % ("".join(b))),
(Token.Column, ""),
]
T.addrow(ins + ins2)
if conf.Code.bytecode:
pad = conf.Code.padding
T.colsize[1] += pad
if conf.Code.header:
th = "# --- block %s ---"
T.header = (th % self.of.address).ljust(T.width, "-")
if conf.Code.footer:
T.footer = "-" * T.width
return T
def test_vltable():
T = render.vltable()
T.addrow([(render.Token.Literal, 'abcd'), (render.Token.Register, 'eax'),
(render.Token.Column, '<-'), (render.Token.Constant, '0x23')])
T.addrow([(render.Token.Literal, 'abcd'), (render.Token.Register, 'ebx'),
(render.Token.Column, '<-'), (render.Token.Mnemonic, 'mov')])
T.addrow([(render.Token.Literal, 'abcdxxxxxxx'),
(render.Token.Register, 'eflags'), (render.Token.Column, '<-'),
(render.Token.Memory, 'M32(eax+1)')])
assert T.nrows == 3
assert T.ncols == 2
assert T.colsize[0] == 17
assert T.getcolsize(0) == 17
T.hiderow(2)
assert T.getcolsize(0) == 7
T.showrow(2)
T.grep('eax', invert=True)
assert T.hidden_r.issuperset((0, 2))
c0 = T.getcolsize(0)
assert c0 == 7
T.setcolsize(0, c0)
T.squash_r = True
T.squash_c = True
s = str(T)
def _vltable(self, **kargs):
t = vltable(**kargs)
w = t.width
th = u'[func %s, signature: %s]'
t.header = (th % (self.of, self.of.sig())).ljust(w, '-')
t.footer = u'_' * w
def _vltable(self, **kargs):
t = vltable(**kargs)
w = t.width
th = "[func %s, signature: %s]"
t.header = (th % (self.of, self.of.sig())).ljust(w, "-")
t.footer = "_" * w
def _vltable(self, **kargs):
t = vltable(**kargs)
t.rowparams["sep"] = icons.sep
# ....
return t
