code stringlengths 26 124k | docstring stringlengths 23 125k | func_name stringlengths 1 98 | language stringclasses 1
value | repo stringlengths 5 53 | path stringlengths 7 151 | url stringlengths 50 211 | license stringclasses 7
values |
|---|---|---|---|---|---|---|---|
def c_program_epilog
if defined? @need_geteip_stub and @need_geteip_stub
return if new_label('metasm_intern_geteip') != 'metasm_intern_geteip' # already defined elsewhere
eax = Reg.new(0, @cpusz)
label = new_label('geteip')
@source << Label.new('metasm_intern_geteip')
instr 'call', Expression[label]
... | adds the metasm_intern_geteip function, which returns its own address in eax (used for PIC addressing) | c_program_epilog | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/compile_c.rb | BSD-3-Clause |
def dbg_alloc_bphw(dbg, bp)
if not bp.internal[:dr]
may = [0, 1, 2, 3]
dbg.breakpoint_thread.values.each { |bb| may.delete bb.internal[:dr] }
raise 'alloc_bphw: no free debugregister' if may.empty?
bp.internal[:dr] = may.first
end
bp.internal[:type] ||= :x
bp.internal[:len] ||= 1
bp.internal[:dr]... | allocate a debug register for a hwbp by checking the list of hwbp existing in dbg | dbg_alloc_bphw | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/debug.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/debug.rb | BSD-3-Clause |
def dbg_stacktrace(dbg, rec=500)
ret = []
s = dbg.addrname!(dbg.pc)
yield(dbg.pc, s) if block_given?
ret << [dbg.pc, s]
fp = dbg.get_reg_value(dbg_register_list[6])
stack = dbg.get_reg_value(dbg_register_list[7]) - 8
while fp > stack and fp <= stack+0x10000 and rec != 0
rec -= 1
ra = dbg.resolve_exp... | return (yield) a list of [addr, symbolic name] | dbg_stacktrace | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/debug.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/debug.rb | BSD-3-Clause |
def dbg_func_arg(dbg, argnr)
dbg.memory_read_int(Expression[:esp, :+, 4*(argnr+1)])
end | retrieve the current function arguments
only valid at function entry (eg right after the call) | dbg_func_arg | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/debug.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/debug.rb | BSD-3-Clause |
def decode_findopcode(edata)
di = DecodedInstruction.new self
while edata.ptr < edata.data.length
pfx = di.instruction.prefix || {}
byte = edata.data[edata.ptr]
byte = byte.unpack('C').first if byte.kind_of?(::String)
return di if di.opcode = @bin_lookaside[byte].find { |op|
# fetch the relevant byt... | tries to find the opcode encoded at edata.ptr
if no match, tries to match a prefix (update di.instruction.prefix)
on match, edata.ptr points to the first byte of the opcode (after prefixes) | decode_findopcode | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def decode_instr_interpret(di, addr)
if di.opcode.props[:setip] and di.instruction.args.last.kind_of? Expression and di.instruction.opname !~ /^i?ret/
delta = di.instruction.args.last.reduce
arg = Expression[[addr, :+, di.bin_length], :+, delta].reduce
di.instruction.args[-1] = Expression[arg]
end
di
e... | converts relative jump/call offsets to absolute addresses
adds the eip delta to the offset +off+ of the instruction (may be an Expression) + its bin_length
do not call twice on the same di ! | decode_instr_interpret | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def decode_cc_to_expr(cc)
case cc
when 'o'; Expression[:eflag_o]
when 'no'; Expression[:'!', :eflag_o]
when 'b', 'nae', 'c'; Expression[:eflag_c]
when 'nb', 'ae', 'nc'; Expression[:'!', :eflag_c]
when 'z', 'e'; Expression[:eflag_z]
when 'nz', 'ne'; Expression[:'!', :eflag_z]
when 'be', 'na'; Expression[... | interprets a condition code (in an opcode name) as an expression involving backtracked eflags
eflag_p is never computed, and this returns Expression::Unknown for this flag
ex: 'z' => Expression[:eflag_z] | decode_cc_to_expr | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def init_backtrace_binding
@backtrace_binding ||= {}
eax, ecx, edx, ebx, esp, ebp, esi, edi = register_symbols
ebx = ebx
mask = lambda { |di| (1 << opsz(di))-1 } # 32bits => 0xffff_ffff
sign = lambda { |v, di| Expression[[[v, :&, mask[di]], :>>, opsz(di)-1], :'!=', 0] }
opcode_list.map { |ol| ol.basename... | populate the @backtrace_binding hash with default values | init_backtrace_binding | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def get_jump_condition(di)
ecx = register_symbols[1]
case di.opcode.name
when /^j(.*)/
decode_cc_to_expr($1)
when /^loop(.+)?/
e = Expression[ecx, :'!=', 0]
e = Expression[e, :'||', decode_cc_to_expr($1)] if $1
e
end
end | returns the condition (bool Expression) under which a conditionnal jump is taken
returns nil if not a conditionnal jump
backtrace for the condition must include the jump itself (eg loop -> ecx--) | get_jump_condition | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def fix_fwdemu_binding(di, fbd)
if di.instruction.args.grep(ModRM).find { |m| m.seg and m.symbolic(di).target.lexpr =~ /^segment_base_/ }
fbd = fbd.dup
fbd[:incomplete_binding] = Expression[1]
end
case di.opcode.name
when 'push', 'call'
fbd = fbd.dup
sz = opsz(di)/8
esp = register_symbols[4]
... | patch a forward binding from the backtrace binding
fixes fwdemu for push/pop/call/ret | fix_fwdemu_binding | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def get_xrefs_x_jmptable(dasm, di, mrm, sz)
# include the symbolic dest for backtrack stuff
ret = [Expression[mrm.symbolic(di)]]
i = mrm.i
if di.block.list.length == 2 and di.block.list[0].opcode.name =~ /^mov/ and a0 = di.block.list[0].instruction.args[0] and
a0.respond_to? :symbolic and a0.symbolic == i.s... | we detected a jmp table (jmp [base+4*idx])
try to return an accurate dest list | get_xrefs_x_jmptable | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def backtrace_is_function_return(expr, di=nil)
expr = Expression[expr].reduce_rec
expr.kind_of? Indirection and expr.len == @size/8 and expr.target == Expression[register_symbols[4]]
end | checks if expr is a valid return expression matching the :saveip instruction | backtrace_is_function_return | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def backtrace_update_function_binding(dasm, faddr, f, retaddrlist, *wantregs)
b = f.backtrace_binding
esp, ebp = register_symbols[4, 2]
# XXX handle retaddrlist for multiple/mixed thunks
if retaddrlist and not dasm.decoded[retaddrlist.first] and di = dasm.decoded[faddr]
# no return instruction, must be a t... | updates the function backtrace_binding
if the function is big and no specific register is given, do nothing (the binding will be lazily updated later, on demand)
XXX assume retaddrlist is either a list of addr of ret or a list with a single entry which is an external function name (thunk) | backtrace_update_function_binding | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def backtrace_is_stack_address(expr)
Expression[expr].expr_externals.include? register_symbols[4]
end | returns true if the expression is an address on the stack | backtrace_is_stack_address | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def replace_instr_arg_immediate(i, old, new)
i.args.map! { |a|
case a
when Expression; a == old ? new : Expression[a.bind(old => new).reduce]
when ModRM
a.imm = (a.imm == old ? new : Expression[a.imm.bind(old => new).reduce]) if a.imm
a
else a
end
}
end | updates an instruction's argument replacing an expression with another (eg label renamed) | replace_instr_arg_immediate | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def decode_c_function_prototype(cp, sym, orig=nil)
sym = cp.toplevel.symbol[sym] if sym.kind_of?(::String)
df = DecodedFunction.new
orig ||= Expression[sym.name]
new_bt = lambda { |expr, rlen|
df.backtracked_for << BacktraceTrace.new(expr, orig, expr, rlen ? :r : :x, rlen)
}
# return instr emulation
... | returns a DecodedFunction from a parsed C function prototype
TODO rebacktrace already decoded functions (load a header file after dasm finished)
TODO walk structs args | decode_c_function_prototype | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def disassembler_default_btbind_callback
esp = register_symbols[4]
lambda { |dasm, bind, funcaddr, calladdr, expr, origin, maxdepth|
@dasm_func_default_off ||= {}
if off = @dasm_func_default_off[[dasm, calladdr]]
bind = bind.merge(esp => Expression[esp, :+, off])
break bind
end
break bind if no... | the lambda for the :default backtrace_binding callback of the disassembler
tries to determine the stack offset of unprototyped functions
working:
checks that origin is a ret, that expr is an indirection from esp and that expr.origin is the ret
bt_walk from calladdr until we finds a call into us, and assumes it is the c... | disassembler_default_btbind_callback | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def disassembler_default_btfor_callback
lambda { |dasm, btfor, funcaddr, calladdr|
if funcaddr != :default; btfor
elsif di = dasm.decoded[calladdr] and (di.opcode.name == 'call' or di.opcode.name == 'jmp'); btfor
else []
end
}
end | the :default backtracked_for callback
returns empty unless funcaddr is not default or calladdr is a call or a jmp | disassembler_default_btfor_callback | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def disassembler_default_func
esp = register_symbols[4]
cp = new_cparser
cp.parse 'void stdfunc(void);'
f = decode_c_function_prototype(cp, 'stdfunc', :default)
f.backtrace_binding[esp] = Expression[esp, :+, :unknown]
f.btbind_callback = disassembler_default_btbind_callback
f.btfor_callback = disassemble... | returns a DecodedFunction suitable for :default
uses disassembler_default_bt{for/bind}_callback | disassembler_default_func | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def code_binding(dasm, entry, finish=nil)
entry = dasm.normalize(entry)
finish = dasm.normalize(finish) if finish
lastdi = nil
binding = {}
bt = lambda { |from, expr, inc_start|
ret = dasm.backtrace(Expression[expr], from, :snapshot_addr => entry, :include_start => inc_start)
ret.length == 1 ? ret.first... | computes the binding of the sequence of code starting at entry included
the binding is a hash showing the value of modified elements at the
end of the code sequence, relative to their value at entry
the elements are all the registers and the memory written to
if finish is nil, the binding will include :ip, which is the... | code_binding | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def name_local_vars(dasm, funcaddr)
esp = register_symbols[4]
func = dasm.function[funcaddr]
subs = []
dasm.trace_function_register(funcaddr, esp => 0) { |di, r, off, trace|
next if r.to_s =~ /flag/
if di.opcode.name == 'call' and tf = di.block.to_normal.find { |t| dasm.function[t] and dasm.function[t].lo... | trace the stack pointer register across a function, rename occurences of esp+XX to esp+var_XX | name_local_vars | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decode.rb | BSD-3-Clause |
def decompile_makestackvars(dasm, funcstart, blocks)
oldfuncbd = dasm.address_binding[funcstart]
dasm.address_binding[funcstart] = { :esp => :frameptr } # this would suffice, the rest here is just optimisation
patched_binding = [funcstart] # list of addresses to cleanup later
ebp_frame = true
# pretrace esp... | temporarily setup dasm.address_binding so that backtracking
stack-related offsets resolve in :frameptr (relative to func start) | decompile_makestackvars | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decompile.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decompile.rb | BSD-3-Clause |
def decompile_func_finddeps(dcmp, blocks, func)
deps_r = {} ; deps_w = {} ; deps_to = {}
deps_subfunc = {} # things read/written by subfuncs
# find read/writes by each block
blocks.each { |b, to|
deps_r[b] = [] ; deps_w[b] = [] ; deps_to[b] = to
deps_subfunc[b] = []
blk = dcmp.dasm.decoded[b].block
... | list variable dependency for each block, remove useless writes
returns { blockaddr => [list of vars that are needed by a following block] } | decompile_func_finddeps | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/decompile.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/decompile.rb | BSD-3-Clause |
def encode(reg = 0, endianness = :little)
reg = reg.val if reg.kind_of? Argument
case @adsz
when 16; encode16(reg, endianness)
when 32; encode32(reg, endianness)
end
end | The argument is an integer representing the 'reg' field of the mrm
caller is responsible for setting the adsz
returns an array, 1 element per possible immediate size (for un-reduce()able Expression) | encode | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/encode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/encode.rb | BSD-3-Clause |
def encode_instr_op(program, i, op)
base = op.bin.dup
oi = op.args.zip(i.args)
set_field = lambda { |f, v|
v ||= 0 # ST => ST(0)
fld = op.fields[f]
base[fld[0]] |= v << fld[1]
}
size = i.prefix[:sz] || @size
#
# handle prefixes and bit fields
#
pfx = i.prefix.map { |k, v|
ca... | returns all forms of the encoding of instruction i using opcode op
program may be used to create a new label for relative jump/call | encode_instr_op | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/encode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/encode.rb | BSD-3-Clause |
def symbolic(di=nil)
s = Sym[@val]
if @sz == 8 and to_s[-1] == ?h
Expression[[Sym[@val-4], :>>, 8], :&, 0xff]
elsif @sz == 8
Expression[s, :&, 0xff]
elsif @sz == 16
Expression[s, :&, 0xffff]
else
s
end
end | returns a symbolic representation of the register:
eax => :eax
cx => :ecx & 0xffff
ah => (:eax >> 8) & 0xff | symbolic | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def share?(other)
other.val % (other.sz >> 1) == @val % (@sz >> 1) and (other.sz != @sz or @sz != 8 or other.val == @val)
end | checks if two registers have bits in common | share? | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def initialize(adsz, sz, s, i, b, imm, seg = nil)
@adsz, @sz = adsz, sz
@s, @i = s, i if i
@b = b if b
@imm = imm if imm
@seg = seg if seg
end | creates a new ModRM with the specified attributes:
- adsz (16/32), sz (8/16/32: byte ptr, word ptr, dword ptr)
- s, i, b, imm
- segment selector override | initialize | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def symbolic(di=nil)
p = nil
p = Expression[p, :+, @b.symbolic(di)] if b
p = Expression[p, :+, [@s, :*, @i.symbolic(di)]] if i
p = Expression[p, :+, @imm] if imm
p = Expression["segment_base_#@seg", :+, p] if seg and seg.val != ((b && (@b.val == 4 || @b.val == 5)) ? 2 : 3)
Indirection[p.reduce, @sz/8,... | returns the symbolic representation of the ModRM (ie an Indirection)
segment selectors are represented as eg "segment_base_fs"
not present when same as implicit (ds:edx, ss:esp) | symbolic | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def initialize(*a)
super()
@size = (a & [16, 32]).first || 32
a.delete @size
@endianness = (a & [:big, :little]).first || :little
a.delete @endianness
@family = a.pop || :latest
raise "Invalid arguments #{a.inspect}" if not a.empty?
raise "Invalid Ia32 family #{@family.inspect}" if not respond_to?("init... | Create a new instance of an Ia32 cpu
arguments (any order)
- size in bits (16, 32) [32]
- instruction set (386, 486, pentium...) [latest]
- endianness [:little] | initialize | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def tune_prepro(pp, nodefine = false)
super(pp)
return if nodefine
pp.define_weak('_M_IX86', 500)
pp.define_weak('_X86_')
pp.define_weak('__i386__')
end | defines some preprocessor macros to say who we are:
_M_IX86 = 500, _X86_, __i386__
pass any value in nodefine to just call super w/o defining anything of our own | tune_prepro | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def str_to_reg(str)
Reg.s_to_i.has_key?(str) ? Reg.from_str(str) : SimdReg.s_to_i.has_key?(str) ? SimdReg.from_str(str) : nil
end | returns a Reg/SimdReg object if the arg is a valid register (eg 'ax' => Reg.new(0, 16))
returns nil if str is invalid | str_to_reg | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def instr_args_regs(i)
i = i.instruction if i.kind_of?(DecodedInstruction)
i.args.grep(Reg)
end | returns the list of Regs in the instruction arguments
may be converted into symbols through Reg#symbolic | instr_args_regs | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def instr_args_memoryptr(i)
i = i.instruction if i.kind_of?(DecodedInstruction)
i.args.grep(ModRM)
end | returns the list of ModRMs in the instruction arguments
may be converted into Indirection through ModRM#symbolic | instr_args_memoryptr | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def instr_args_memoryptr_getbase(mrm)
mrm.b || (mrm.i if mrm.s == 1)
end | return the 'base' of the ModRM (Reg/nil) | instr_args_memoryptr_getbase | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def instr_args_memoryptr_setoffset(mrm, imm)
mrm.imm = (imm ? Expression[imm] : imm)
end | define ModRM offset (eg to changing imm into an ExpressionString) | instr_args_memoryptr_setoffset | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/main.rb | BSD-3-Clause |
def init_386_common_only
init_cpu_constants
addop_macro1 'adc', 2
addop_macro1 'add', 0
addop_macro1 'and', 4, :unsigned_imm
addop 'bswap', [0x0F, 0xC8], :reg
addop 'call', [0xE8], nil, :stopexec, :setip, :i, :saveip
addop 'call', [0xFF], 2, :stopexec, :setip, :saveip
addop('cbw', [0x98]) { |o| o.p... | only most common instructions from the 386 instruction set
inexhaustive list :
no aaa, arpl, mov crX, call/jmp/ret far, in/out, bts, xchg... | init_386_common_only | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/opcodes.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/opcodes.rb | BSD-3-Clause |
def parse_parser_instruction(lexer, instr)
case instr.raw.downcase
when '.mode', '.bits'
lexer.skip_space
if tok = lexer.readtok and tok.type == :string and (tok.raw == '16' or tok.raw == '32')
@size = tok.raw.to_i
lexer.skip_space
raise instr, 'syntax error' if ntok = lexer.nexttok and ntok.type ... | handles cpu-specific parser instruction, falls back to Ancestor's version if unknown keyword
XXX changing the cpu size in the middle of the code may have baaad effects... | parse_parser_instruction | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/parse.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/parse.rb | BSD-3-Clause |
def parse_arg_valid?(o, spec, arg)
if o.name == 'movsx' or o.name == 'movzx'
if not arg.kind_of?(Reg) and not arg.kind_of?(ModRM)
return
elsif not arg.sz
puts "ambiguous arg size for indirection in #{o.name}" if $VERBOSE
return
elsif spec == :reg # reg=dst, modrm=src (smaller)
return (arg.ki... | check if the argument matches the opcode's argument spec | parse_arg_valid? | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/parse.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/parse.rb | BSD-3-Clause |
def parse_instruction_fixup(i)
if m = i.args.grep(ModRM).first and not m.sz
if i.opname == 'movzx' or i.opname == 'movsx'
m.sz = 8
else
if r = i.args.grep(Reg).first
m.sz = r.sz
elsif l = opcode_list_byname[i.opname].map { |o| o.props[:argsz] }.uniq and l.length == 1 and l.first
m.sz = l.f... | fixup the sz of a modrm argument, defaults to other argument size or current cpu mode | parse_instruction_fixup | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ia32/parse.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ia32/parse.rb | BSD-3-Clause |
def decode_instr_interpret(di, addr)
if di.opcode.props[:setip] and di.instruction.args.last.kind_of? Expression and di.opcode.name[0] != ?t
delta = Expression[di.instruction.args.last, :<<, 2].reduce
if di.opcode.args.include? :i26
# absolute jump in the 0x3ff_ffff region surrounding next_pc
if delta.k... | converts relative branch offsets to absolute addresses
else just add the offset +off+ of the instruction + its length (off may be an Expression)
assumes edata.ptr points just after the instruction (as decode_instr_op left it)
do not call twice on the same di ! | decode_instr_interpret | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/mips/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/mips/decode.rb | BSD-3-Clause |
def backtrace_found_result(dasm, di, expr, type, len)
if di.opcode.name == 'jalr' and di.instruction.args == [:$t9]
expr = dasm.normalize(expr)
(dasm.address_binding[expr] ||= {})[:$t9] ||= expr
end
end | make the target of the call know the value of $t9 (specified by the ABI)
XXX hackish | backtrace_found_result | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/mips/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/mips/decode.rb | BSD-3-Clause |
def decode_instr_interpret(di, addr)
if di.opcode.props[:setip] and di.instruction.args.last.kind_of? Expression and di.opcode.name[0] != ?t and di.opcode.name[-1] != ?a
arg = Expression[addr, :+, di.instruction.args.last].reduce
di.instruction.args[-1] = Expression[arg]
end
di
end | converts relative branch offsets to absolute addresses
else just add the offset +off+ of the instruction + its length (off may be an Expression)
assumes edata.ptr points just after the instruction (as decode_instr_op left it)
do not call twice on the same di ! | decode_instr_interpret | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ppc/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ppc/decode.rb | BSD-3-Clause |
def decompile_makestackvars(dasm, funcstart, blocks)
oldfuncbd = dasm.address_binding[funcstart]
dasm.address_binding[funcstart] = { :sp => :frameptr } # this would suffice, the rest here is just optimisation
blocks.each { |block|
yield block
}
dasm.address_binding[funcstart] = oldfuncbd if oldfuncbd
en... | temporarily setup dasm.address_binding so that backtracking
stack-related offsets resolve in :frameptr (relative to func start) | decompile_makestackvars | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ppc/decompile.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ppc/decompile.rb | BSD-3-Clause |
def decompile_func_finddeps(dcmp, blocks, func)
deps_r = {} ; deps_w = {} ; deps_to = {}
deps_subfunc = {} # things read/written by subfuncs
# find read/writes by each block
blocks.each { |b, to|
deps_r[b] = [] ; deps_w[b] = [] ; deps_to[b] = to
deps_subfunc[b] = []
blk = dcmp.dasm.decoded[b].block
... | list variable dependency for each block, remove useless writes
returns { blockaddr => [list of vars that are needed by a following block] } | decompile_func_finddeps | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ppc/decompile.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ppc/decompile.rb | BSD-3-Clause |
def addop_branch(nbase, bin, *argprops)
nbase += 'ctr' if argprops.delete :ctr
nbase += 'lr' if argprops.delete :lr
addop(nbase, bin, :setip, *argprops)
addop(nbase+'l', bin|1, :setip, :saveip, *argprops)
return if nbase[-2, 2] == 'lr' or nbase[-3, 3] == 'ctr'
addop(nbase+'a', bin|2, :setip, *arg... | generate l/a variations, add :setip/:saveip, include lr/ctr in opname | addop_branch | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/ppc/opcodes.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/ppc/opcodes.rb | BSD-3-Clause |
def transfer_size_mode(list)
return list if list.find { |op| not op.name.include? 'mov' }
@transfersz == 0 ? list.find_all { |op| op.name.include? 'fmov.s' } : list.reject { |op| op.name.include? 'fmov.s' }
end | depending on transfert size mode (sz flag), fmov instructions manipulate single ou double precision values
instruction aliasing appears when sz is not handled | transfer_size_mode | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/sh4/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/sh4/decode.rb | BSD-3-Clause |
def precision_mode(list)
@fpprecision == 0 ? list.reject { |op| op.args.include? :drn } : list.find_all { |op| op.args.include? :frn }
end | when pr flag is set, floating point instructions are executed as double-precision operations
thus register pair is used (DRn registers) | precision_mode | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/sh4/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/sh4/decode.rb | BSD-3-Clause |
def decode_cmp_expr(di, a0, a1)
case di.opcode.name
when 'cmp/eq'; Expression[a0, :'==', a1]
when 'cmp/ge'; Expression[a0, :'>=', a1] # signed
when 'cmp/gt'; Expression[a0, :'>', a1] # signed
when 'cmp/hi'; Expression[a0, :'>', a1] # unsigned
when 'cmp/hs'; Expression[a0, :'>=', a1] # unsigned
end
end | interprets a condition code (in an opcode name) as an expression | decode_cmp_expr | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/sh4/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/sh4/decode.rb | BSD-3-Clause |
def instr(name, *args)
# XXX parse_postfix ?
@source << Instruction.new(@exeformat.cpu, name, args)
end | shortcut to add an instruction to the source | instr | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def findreg(sz = @cpusz)
caching = @state.cache.keys.grep(Reg).map { |r| r.val }
if not regval = (@state.abi_trashregs - @state.used - caching).first ||
([*0..@regnummax] - @state.used).first
raise 'need more registers! (or a better compiler?)'
end
getreg(regval, sz)
end | returns an available register, tries to find one not in @state.cache
do not use with sz==8 (aliasing ah=>esp)
does not put it in @state.inuse | findreg | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def getreg(regval, sz=@cpusz)
flushcachereg(regval)
@state.dirty |= [regval]
Reg.new(regval, sz)
end | returns a Reg from a regval, mark it as dirty, flush old cache dependencies | getreg | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def flushcachereg(regval)
@state.cache.delete_if { |e, val|
case e
when Reg; e.val == regval
when Address; e = e.modrm ; redo
when ModRM; e.b && (e.b.val == regval) or e.i && (e.i.val == regval)
end
}
end | remove the cache keys that depends on the register | flushcachereg | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def unuse(*vals)
vals.each { |val|
val = val.modrm if val.kind_of? Address
@state.inuse.delete val
}
# XXX cache exempt
exempt = @state.bound.values.map { |r| r.val }
exempt << 4
exempt << 5 if @state.saved_rbp
@state.used.delete_if { |regval|
next if exempt.include? regval
not @state.inuse.fi... | removes elements from @state.inuse, free @state.used if unreferenced
must be the exact object present in inuse | unuse | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def inuse(v)
case v
when Reg; @state.used |= [v.val]
when ModRM
@state.used |= [v.i.val] if v.i
@state.used |= [v.b.val] if v.b
when Address; inuse v.modrm ; return v
else return v
end
@state.inuse |= [v]
v
end | marks an arg as in use, returns the arg | inuse | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def findvar(var)
if ret = @state.bound[var]
return ret
end
if ret = @state.cache.index(var)
ret = ret.dup
inuse ret
return ret
end
sz = 8*sizeof(var) rescue nil # extern char foo[];
case off = @state.offset[var]
when C::CExpression
# stack, dynamic address
# TODO
# no need to updat... | returns a variable storage (ModRM for stack/global, Reg/Composite for register-bound) | findvar | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def resolve_address(e)
r = e.modrm
unuse e
if r.imm and not r.b and not r.i
reg = r.imm
elsif not r.imm and ((not r.b and r.s == 1) or not r.i)
reg = r.b || r.i
elsif reg = @state.cache.index(e)
reg = reg.dup
else
reg = findreg
r.sz = reg.sz
instr 'lea', reg, r
end
inuse reg
@state.c... | resolves the Address to Reg/Expr (may encode an 'lea') | resolve_address | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def make_volatile(e, type, rsz=@cpusz)
if e.kind_of? ModRM or @state.bound.index(e)
if type.integral? or type.pointer?
oldval = @state.cache[e]
unuse e
sz = typesize[type.pointer? ? :ptr : type.name]*8
if sz < @cpusz or sz < rsz or e.sz < rsz
e2 = inuse findreg(rsz)
op = ((type.specifier ... | copies the arg e to a volatile location (register/composite) if it is not already
unuses the old storage
may return a register bigger than the type size (eg __int8 are stored in full reg size) | make_volatile | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def i_to_i32(v)
if v.kind_of? Expression and i = v.reduce and i.kind_of?(Integer)
i &= 0xffff_ffff_ffff_ffff
if i <= 0x7fff_ffff
elsif i >= (1<<64)-0x8000_0000
v = Expression[Expression.make_signed(i, 64)]
else
v = make_volatile(v, C::BaseType.new(:int))
unuse v
end
end
v
end | takes an argument, if the argument is an integer that does not fit in an i32, moves it to a temp reg
the reg is unused, so use this only right when generating the offending instr (eg cmp, add..) | i_to_i32 | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def getcc(op, type)
case op
when :'=='; 'z'
when :'!='; 'nz'
when :'<' ; 'b'
when :'>' ; 'a'
when :'<='; 'be'
when :'>='; 'ae'
else raise "bad comparison op #{op}"
end.tr((type.specifier == :unsigned ? '' : 'ab'), 'gl')
end | returns the instruction suffix for a comparison operator | getcc | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def c_cexpr_inner(expr)
case expr
when ::Integer; Expression[expr]
when C::Variable; findvar(expr)
when C::CExpression
if not expr.lexpr or not expr.rexpr
inuse c_cexpr_inner_nol(expr)
else
inuse c_cexpr_inner_l(expr)
end
when C::Label; findvar(C::Variable.new(expr.name, C::Array.new(C::BaseT... | compiles a c expression, returns an X64 instruction argument | c_cexpr_inner | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def c_cexpr_inner_l(expr)
case expr.op
when :funcall
c_cexpr_inner_funcall(expr)
when :'+=', :'-=', :'*=', :'/=', :'%=', :'^=', :'&=', :'|=', :'<<=', :'>>='
l = c_cexpr_inner(expr.lexpr)
raise 'bad lvalue' if not l.kind_of? ModRM and not @state.bound.index(l)
r = c_cexpr_inner(expr.rexpr)
op = expr... | compiles a CExpression, not arithmetic (assignment, comparison etc) | c_cexpr_inner_l | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def c_cexpr_inner_arith_int(l, op, r, type)
op = case op
when :+; 'add'
when :-; 'sub'
when :&; 'and'
when :|; 'or'
when :^; 'xor'
when :>>; type.specifier == :unsigned ? 'shr' : 'sar'
when :<<; 'shl'
when :*; 'mul'
when :/; 'div'
when :%; 'mod'
end
case op
when 'add', 'sub', 'and', 'or', '... | compile an integral arithmetic expression, reg-sized | c_cexpr_inner_arith_int | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/compile_c.rb | BSD-3-Clause |
def decode_c_function_prototype(cp, sym, orig=nil)
sym = cp.toplevel.symbol[sym] if sym.kind_of?(::String)
df = DecodedFunction.new
orig ||= Expression[sym.name]
new_bt = lambda { |expr, rlen|
df.backtracked_for << BacktraceTrace.new(expr, orig, expr, rlen ? :r : :x, rlen)
}
# return instr emulation
... | returns a DecodedFunction from a parsed C function prototype | decode_c_function_prototype | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/decode.rb | BSD-3-Clause |
def encode_instr_op(program, i, op)
base = op.bin.dup
oi = op.args.zip(i.args)
set_field = lambda { |f, v|
fld = op.fields[f]
base[fld[0]] |= v << fld[1]
}
#
# handle prefixes and bit fields
#
pfx = i.prefix.map { |k, v|
case k
when :jmp; {:jmp => 0x3e, :nojmp => 0x2e}[v]
wh... | returns all forms of the encoding of instruction i using opcode op
program may be used to create a new label for relative jump/call | encode_instr_op | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/encode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/encode.rb | BSD-3-Clause |
def symbolic(di=nil)
s = Sym[@val]
s = di.next_addr if s == :rip and di
if @sz == 8 and to_s[-1] == ?h
Expression[[Sym[@val-16], :>>, 8], :&, 0xff]
elsif @sz == 8
Expression[s, :&, 0xff]
elsif @sz == 16
Expression[s, :&, 0xffff]
elsif @sz == 32
Expression[s, :&, 0xffffffff]
else
... | returns a symbolic representation of the register:
cx => :rcx & 0xffff
ah => (:rax >> 8) & 0xff
XXX in x64, 32bits operations are zero-extended to 64bits (eg mov rax, 0x1234_ffff_ffff ; add eax, 1 => rax == 0 | symbolic | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/main.rb | BSD-3-Clause |
def share?(other)
raise 'TODO'
# XXX TODO wtf does formula this do ?
other.val % (other.sz >> 1) == @val % (@sz >> 1) and (other.sz != @sz or @sz != 8 or other.val == @val)
end | checks if two registers have bits in common | share? | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/main.rb | BSD-3-Clause |
def val_enc
if @sz == 8 and @val >= 16; @val-12 # ah, bh, ch, dh
elsif @val >= 16 # rip
else @val & 7 # others
end
end | returns the part of @val to encode in an instruction field | val_enc | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/main.rb | BSD-3-Clause |
def val_rex
if @sz == 8 and @val >= 16 # ah, bh, ch, dh: rex forbidden
elsif @val >= 16 # rip
else @val >> 3 # others
end
end | returns the part of @val to encode in an instruction's rex prefix | val_rex | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/main.rb | BSD-3-Clause |
def initialize(*a)
super(:latest)
@size = 64
a.delete @size
@endianness = (a & [:big, :little]).first || :little
a.delete @endianness
@family = a.pop || :latest
raise "Invalid arguments #{a.inspect}" if not a.empty?
raise "Invalid X86_64 family #{@family.inspect}" if not respond_to?("init_#@family")
en... | Create a new instance of an X86 cpu
arguments (any order)
- instruction set (386, 486, sse2...) [latest]
- endianness [:little] | initialize | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/main.rb | BSD-3-Clause |
def tune_prepro(pp)
super(pp, :itsmeX64) # ask Ia32's to just call super()
pp.define_weak('_M_AMD64')
pp.define_weak('_M_X64')
pp.define_weak('__amd64__')
pp.define_weak('__x86_64__')
end | defines some preprocessor macros to say who we are:
TODO | tune_prepro | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/main.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/main.rb | BSD-3-Clause |
def parse_argregclasslist
[Reg, SimdReg, SegReg, DbgReg, TstReg, CtrlReg, FpReg]
end | needed due to how ruby inheritance works wrt constants | parse_argregclasslist | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/parse.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/parse.rb | BSD-3-Clause |
def parse_arg_valid?(o, spec, arg)
return if arg.kind_of? ModRM and ((arg.b and arg.b.val == 16 and arg.i) or (arg.i and arg.i.val == 16 and (arg.b or arg.s != 1)))
return if arg.kind_of? Reg and arg.sz >= 32 and arg.val == 16 # eip/rip only in modrm
return if o.props[:auto64] and arg.respond_to? :sz and arg.sz =... | check if the argument matches the opcode's argument spec | parse_arg_valid? | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/x86_64/parse.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/x86_64/parse.rb | BSD-3-Clause |
def decode_findopcode(edata)
di = DecodedInstruction.new self
while edata.ptr < edata.data.length
byte = edata.data[edata.ptr]
byte = byte.unpack('C').first if byte.kind_of?(::String)
return di if di.opcode = @bin_lookaside[byte].find { |op|
# fetch the relevant bytes from edata
bseq = edata.data[e... | tries to find the opcode encoded at edata.ptr
if no match, tries to match a prefix (update di.instruction.prefix)
on match, edata.ptr points to the first byte of the opcode (after prefixes) | decode_findopcode | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/z80/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/z80/decode.rb | BSD-3-Clause |
def init_backtrace_binding
@backtrace_binding ||= {}
mask = 0xffff
opcode_list.map { |ol| ol.basename }.uniq.sort.each { |op|
binding = case op
when 'ld'; lambda { |di, a0, a1, *aa| a2 = aa[0] ; a2 ? { a0 => Expression[a1, :+, a2] } : { a0 => Expression[a1] } }
when 'ldi'; lambda { |di, a0, a1| hl = (a... | populate the @backtrace_binding hash with default values | init_backtrace_binding | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/z80/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/z80/decode.rb | BSD-3-Clause |
def fix_fwdemu_binding(di, fbd)
case di.opcode.name
when 'push', 'call'; fbd[Indirection[[:sp, :-, 2], 2]] = fbd.delete(Indirection[:sp, 2])
end
fbd
end | patch a forward binding from the backtrace binding | fix_fwdemu_binding | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/z80/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/z80/decode.rb | BSD-3-Clause |
def backtrace_is_function_return(expr, di=nil)
expr = Expression[expr].reduce_rec
expr.kind_of?(Indirection) and expr.len == 2 and expr.target == Expression[:sp]
end | checks if expr is a valid return expression matching the :saveip instruction | backtrace_is_function_return | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/z80/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/z80/decode.rb | BSD-3-Clause |
def backtrace_update_function_binding(dasm, faddr, f, retaddrlist, *wantregs)
b = f.backtrace_binding
bt_val = lambda { |r|
next if not retaddrlist
b[r] = Expression::Unknown
bt = []
retaddrlist.each { |retaddr|
bt |= dasm.backtrace(Expression[r], retaddr, :include_start => true,
:snapsho... | updates the function backtrace_binding
if the function is big and no specific register is given, do nothing (the binding will be lazily updated later, on demand) | backtrace_update_function_binding | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/z80/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/z80/decode.rb | BSD-3-Clause |
def replace_instr_arg_immediate(i, old, new)
i.args.map! { |a|
case a
when Expression; a == old ? new : Expression[a.bind(old => new).reduce]
when Memref
a.offset = (a.offset == old ? new : Expression[a.offset.bind(old => new).reduce]) if a.offset
a
else a
end
}
end | updates an instruction's argument replacing an expression with another (eg label renamed) | replace_instr_arg_immediate | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/z80/decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/z80/decode.rb | BSD-3-Clause |
def init_z80_common
@opcode_list = []
@valid_args.update [:i8, :u8, :i16, :u16, :m16,
:r_a, :r_af, :r_hl, :r_de, :r_sp, :r_i,
:m_bc, :m_de, :m_sp, :m_hl, :mf8, :mfc
].inject({}) { |h, v| h.update v => true }
@fields_mask.update :rz => 7, :ry => 7, :rp => 3, :rp2 => 3, :iy => 7, :iy8 => 7
@fields_shift.u... | data from http://www.z80.info/decoding.htm | init_z80_common | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/z80/opcodes.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/z80/opcodes.rb | BSD-3-Clause |
def init_gb
init_z80_common
addop 'ld', [0x08], :m16, :r_sp
addop 'stop', [0x10]
addop 'ldi', [0x22], :m_hl, :r_a # (hl++) <- a
addop 'ldi', [0x2A], :r_a, :m_hl
addop 'ldd', [0x32], :m_hl, :r_a # (hl--) <- a
addop 'ldd', [0x3A], :r_a, :m_hl
addop 'reti', [0xD9], :setip, :stopexec
# override ... | gameboy processor
from http://nocash.emubase.de/pandocs.htm#cpucomparisionwithz80 | init_gb | ruby | stephenfewer/grinder | node/lib/metasm/metasm/cpu/z80/opcodes.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/cpu/z80/opcodes.rb | BSD-3-Clause |
def member(name)
@members.find { |m| m.name == name }
end | return the 1st member whose name is name | member | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff.rb | BSD-3-Clause |
def decode(coff)
return set_default_values(coff) if coff.header.size_opthdr == 0 and not coff.header.characteristics.include?('EXECUTABLE_IMAGE')
off = coff.curencoded.ptr
super(coff)
nrva = (coff.header.size_opthdr - (coff.curencoded.ptr - off)) / 8
nrva = @numrva if nrva < 0
if nrva > DIRECTORIES.l... | decodes a COFF optional header from coff.cursection
also decodes directories in coff.directory | decode | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode(coff)
super(coff)
if coff.sect_at_rva(@libname_p)
@libname = coff.decode_strz
end
if coff.sect_at_rva(@func_p)
@exports = []
addrs = []
@num_exports.times { addrs << coff.decode_word }
@num_exports.times { |i|
e = Export.new
e.ordinal = i + @ordinal_base
addr ... | decodes a COFF export table from coff.cursection | decode | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode(coff)
super(coff)
len = coff.decode_word
len -= 8
if len < 0 or len % 2 != 0
puts "W: COFF: Invalid relocation table length #{len+8}" if $VERBOSE
coff.curencoded.read(len) if len > 0
@relocs = []
return
end
@relocs = coff.curencoded.read(len).unpack(coff.endianness == :big ... | decodes a relocation table from coff.encoded.ptr | decode | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def sect_at_rva(rva)
return if not rva or rva <= 0
if sections and not @sections.empty?
if s = @sections.find { |s_| s_.virtaddr <= rva and s_.virtaddr + EncodedData.align_size((s_.virtsize == 0 ? s_.rawsize : s_.virtsize), @optheader.sect_align) > rva }
s.encoded.ptr = rva - s.virtaddr
@cursection = s
... | converts an RVA (offset from base address of file when loaded in memory) to the section containing it using the section table
updates @cursection and @cursection.encoded.ptr to point to the specified address
may return self when rva points to the coff header
returns nil if none match, 0 never matches | sect_at_rva | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def fileoff_to_addr(foff)
if s = @sections.find { |s_| s_.rawaddr <= foff and s_.rawaddr + s_.rawsize > foff }
s.virtaddr + foff - s.rawaddr + (@load_address ||= @optheader.image_base)
elsif foff >= 0 and foff < @optheader.headers_size
foff + (@load_address ||= @optheader.image_base)
end
end | file offset -> memory address
handles LoadedPE | fileoff_to_addr | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode_header
@cursection ||= self
@encoded.ptr ||= 0
@sections = []
@header.decode(self)
optoff = @encoded.ptr
@optheader.decode(self)
decode_symbols if @header.num_sym != 0 and not @header.characteristics.include? 'DEBUG_STRIPPED'
curencoded.ptr = optoff + @header.size_opthdr
decode_sections
i... | decodes the COFF header, optional header, section headers
marks entrypoint and directories as edata.expord | decode_header | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode_symbols
endptr = @encoded.ptr = @header.ptr_sym + 18*@header.num_sym
strlen = decode_word
@encoded.ptr = endptr
strtab = @encoded.read(strlen)
@encoded.ptr = @header.ptr_sym
@symbols = []
@header.num_sym.times {
break if @encoded.ptr >= endptr or @encoded.ptr >= @encoded.length
@symbols <... | decode the COFF symbol table (obj only) | decode_symbols | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode_section_body(s)
raw = EncodedData.align_size(s.rawsize, @optheader.file_align)
virt = s.virtsize
virt = raw = s.rawsize if @header.size_opthdr == 0
virt = raw if virt == 0
virt = EncodedData.align_size(virt, @optheader.sect_align)
s.encoded = @encoded[s.rawaddr, [raw, virt].min] || EncodedData.ne... | decodes a section content (allows simpler LoadedPE override) | decode_section_body | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode_exports
if @directory['export_table'] and sect_at_rva(@directory['export_table'][0])
@export = ExportDirectory.decode(self)
@export.exports.to_a.each { |e|
if e.name and sect_at_rva(e.target)
name = e.name
elsif e.ordinal and sect_at_rva(e.target)
name = "ord_#{@export.libname}_#{e.... | decodes COFF export table from directory
mark exported names as encoded.export | decode_exports | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode_imports
if @directory['import_table'] and sect_at_rva(@directory['import_table'][0])
@imports = ImportDirectory.decode_all(self)
iatlen = @bitsize/8
@imports.each { |id|
if sect_at_rva(id.iat_p)
ptr = curencoded.ptr
id.imports.each { |i|
if i.name
name = new_label i.name... | decodes COFF import tables from directory
mark iat entries as encoded.export | decode_imports | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode_relocs
if @directory['base_relocation_table'] and sect_at_rva(@directory['base_relocation_table'][0])
end_ptr = curencoded.ptr + @directory['base_relocation_table'][1]
@relocations = []
while curencoded.ptr < end_ptr
@relocations << RelocationTable.decode(self)
end
# interpret as Encode... | decode COFF relocation tables from directory | decode_relocs | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode_reloc_i386(r)
case r.type
when 'ABSOLUTE'
when 'HIGHLOW'
addr = decode_word
if s = sect_at_va(addr)
label = label_at(s.encoded, s.encoded.ptr, "xref_#{Expression[addr]}")
Metasm::Relocation.new(Expression[label], :u32, @endianness)
end
when 'DIR64'
addr = decode_xword
if s = se... | decodes an I386 COFF relocation pointing to encoded.ptr | decode_reloc_i386 | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode_tls
if @directory['tls_table'] and sect_at_rva(@directory['tls_table'][0])
@tls = TLSDirectory.decode(self)
if s = sect_at_va(@tls.callback_p)
s.encoded.add_export 'tls_callback_table'
@tls.callbacks.each_with_index { |cb, i|
@tls.callbacks[i] = curencoded.add_export "tls_callback_#{i}" ... | decode TLS directory, including tls callback table | decode_tls | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def decode
decode_header
decode_exports
decode_imports
decode_resources
decode_certificates
decode_debug
decode_tls
decode_loadconfig
decode_delayimports
decode_com
decode_relocs unless nodecode_relocs or ENV['METASM_NODECODE_RELOCS'] # decode relocs last
end | decodes a COFF file (headers/exports/imports/relocs/sections)
starts at encoded.ptr | decode | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def cpu_from_headers
case @header.machine
when 'I386'; Ia32.new
when 'AMD64'; X86_64.new
when 'R4000'; MIPS.new(:little)
else raise "unknown cpu #{@header.machine}"
end
end | returns a metasm CPU object corresponding to +header.machine+ | cpu_from_headers | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def get_default_entrypoints
ep = []
ep.concat @tls.callbacks.to_a if tls
ep << (@optheader.image_base + label_rva(@optheader.entrypoint))
@export.exports.to_a.each { |e|
next if e.forwarder_lib or not e.target
ep << (@optheader.image_base + label_rva(e.target))
} if export
ep
end | returns an array including the PE entrypoint and the exported functions entrypoints
TODO filter out exported data, include safeseh ? | get_default_entrypoints | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def section_info
[['header', @optheader.image_base, @optheader.headers_size, nil]] +
@sections.map { |s|
[s.name, @optheader.image_base + s.virtaddr, s.virtsize, s.characteristics.join(',')]
}
end | returns an array of [name, addr, length, info] | section_info | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
def fixup_names
@members.each { |m|
case m.name
when '/'
when '//'
when /^\/(\d+)/
@longnames.ptr = $1.to_i
m.name = decode_strz(@longnames).chomp("/")
else m.name.chomp! "/"
end
}
end | set real name to archive members
look it up in the name table member if needed, or just remove the trailing / | fixup_names | ruby | stephenfewer/grinder | node/lib/metasm/metasm/exe_format/coff_decode.rb | https://github.com/stephenfewer/grinder/blob/master/node/lib/metasm/metasm/exe_format/coff_decode.rb | BSD-3-Clause |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.