metasm 1.0.4 → 1.0.6

data/metasm/exe_format/elf.rb

@@ -393,7 +393,8 @@ class ELF < ExeFormat
 			15 => 'PC8', 16 => 'DTPMOD64', 17 => 'DTPOFF64',
 			18 => 'TPOFF64', 19 => 'TLSGD', 20 => 'TLSLD',
 			21 => 'DTPOFF32', 22 => 'GOTTPOFF', 23 => 'TPOFF32' },
-		'OPENRISC' => { 0 => 'NONE', 1 => '32', 2 => '16', 3 => '8',
+		'OPENRISC' => { 0 => 'NONE',
+			1 => '32', 2 => '16', 3 => '8',
 			4 => 'LO_16_IN_INSN', 5 => 'HI_16_IN_INSN', 6 => 'INSN_REL_26', 7 => 'GNU_VTENTRY',
 			8 => 'GNU_VTINHERIT', 9 => '32_PCREL', 10 => '16_PCREL', 11 => '8_PCREL',
 			12 => 'GOTPC_HI16', 13 => 'GOTPC_LO16', 14 => 'GOT15', 15 => 'PLT26',
@@ -402,6 +403,53 @@ class ELF < ExeFormat
 			24 => 'TLS_LDM_HI16', 25 => 'TLS_LDM_LO16', 26 => 'TLS_LDO_HI16', 27 => 'TLS_LDO_LO16',
 			28 => 'TLS_IE_HI16', 29 => 'TLS_IE_LO16', 30 => 'TLS_LE_HI16', 31 => 'TLS_LE_LO16',
 			32 => 'TLS_TPOFF', 33 => 'TLS_DTPOFF', 34 => 'TLS_DTPMOD' },
+		'AARCH64' => {
+			0x100 => 'NONE',
+			0x101 => 'ABS64', 0x102 => 'ABS32', 0x103 => 'ABS16',
+			0x104 => 'PREL64', 0x105 => 'PREL32', 0x106 => 'PREL16',
+			0x107 => 'MOVW_UABS_G0', 0x108 => 'MOVW_UABS_G0_NC',
+			0x109 => 'MOVW_UABS_G1', 0x10a => 'MOVW_UABS_G1_NC',
+			0x10b => 'MOVW_UABS_G2', 0x10c => 'MOVW_UABS_G2_NC',
+			0x10d => 'MOVW_UABS_G3', 0x10e => 'MOVW_SABS_G0',
+			0x10f => 'MOVW_SABS_G1', 0x110 => 'MOVW_SABS_G2',
+			0x111 => 'LD_PREL_LO19', 0x112 => 'ADR_PREL_LO21',
+			0x113 => 'ADR_PREL_PG_HI21', 0x115 => 'ADD_ABS_LO12_NC',
+			0x116 => 'LDST8_ABS_LO12_NC', 0x117 => 'TSTBR14', 0x118 => 'CONDBR19',
+			0x11a => 'JUMP26', 0x11b => 'CALL26',
+			0x11c => 'LDST16_ABS_LO12_NC', 0x11d => 'LDST32_ABS_LO12_NC',
+			0x11e => 'LDST64_ABS_LO12_NC', 0x12b => 'LDST128_ABS_LO12_NC',
+			0x137 => 'ADR_GOT_PAGE', 0x138 => 'LD64_GOT_LO12_NC',
+			0x20b => 'TLSLD_MOVW_DTPREL_G2',
+			0x20c => 'TLSLD_MOVW_DTPREL_G1', 0x20d => 'TLSLD_MOVW_DTPREL_G1_NC',
+			0x20e => 'TLSLD_MOVW_DTPREL_G0', 0x20f => 'TLSLD_MOVW_DTPREL_G0_NC',
+			0x210 => 'TLSLD_ADD_DTPREL_HI12',
+			0x211 => 'TLSLD_ADD_DTPREL_LO12', 0x212 => 'TLSLD_ADD_DTPREL_LO12_NC',
+			0x213 => 'TLSLD_LDST8_DTPREL_LO12', 0x214 => 'TLSLD_LDST8_DTPREL_LO12_NC',
+			0x215 => 'TLSLD_LDST16_DTPREL_LO12', 0x216 => 'TLSLD_LDST16_DTPREL_LO12_NC',
+			0x217 => 'TLSLD_LDST32_DTPREL_LO12', 0x218 => 'TLSLD_LDST32_DTPREL_LO12_NC',
+			0x219 => 'TLSLD_LDST64_DTPREL_LO12', 0x21a => 'TLSLD_LDST64_DTPREL_LO12_NC',
+			0x21b => 'TLSIE_MOVW_GOTTPREL_G1', 0x21c => 'TLSIE_MOVW_GOTTPREL_G0_NC',
+			0x21d => 'TLSIE_ADR_GOTTPREL_PAGE21', 0x21e => 'TLSIE_LD64_GOTTPREL_LO12_NC',
+			0x21f => 'TLSIE_LD_GOTTPREL_PREL19', 0x220 => 'TLSLE_MOVW_TPREL_G2',
+			0x221 => 'TLSLE_MOVW_TPREL_G1', 0x222 => 'TLSLE_MOVW_TPREL_G1_NC',
+			0x223 => 'TLSLE_MOVW_TPREL_G0', 0x224 => 'TLSLE_MOVW_TPREL_G0_NC',
+			0x225 => 'TLSLE_ADD_TPREL_HI12',
+			0x226 => 'TLSLE_ADD_TPREL_LO12', 0x227 => 'TLSLE_ADD_TPREL_LO12_NC',
+			0x228 => 'TLSLE_LDST8_TPREL_LO12', 0x229 => 'TLSLE_LDST8_TPREL_LO12_NC',
+			0x22a => 'TLSLE_LDST16_TPREL_LO12', 0x22b => 'TLSLE_LDST16_TPREL_LO12_NC',
+			0x22c => 'TLSLE_LDST32_TPREL_LO12', 0x22d => 'TLSLE_LDST32_TPREL_LO12_NC',
+			0x22e => 'TLSLE_LDST64_TPREL_LO12', 0x22f => 'TLSLE_LDST64_TPREL_LO12_NC',
+			0x232 => 'TLSDESC_ADR_PAGE', 0x233 => 'TLSDESC_LD64_LO12_NC',
+			0x234 => 'TLSDESC_ADD_LO12_NC',
+			0x235 => 'TLSDESC_OFF_G1', 0x236 => 'TLSDESC_OFF_G0_NC',	# from musl from this line
+			0x237 => 'TLSDESC_LDR', 0x238 => 'TLSDESC_ADD',
+			0x239 => 'TLSDESC_CALL', 0x23a => 'TLSLE_LDST128_TPREL_LO12',
+			0x23b => 'TLSLE_LDST128_TPREL_LO12_NC', 0x23c => 'TLSLD_LDST128_DTPREL_LO12',
+			0x23d => 'TLSLD_LDST128_DTPREL_LO12_NC',
+			0x400 => 'COPY', 0x401 => 'GLOB_DAT',
+			0x402 => 'JUMP_SLOT', 0x403 => 'RELATIVE',
+			0x404 => 'TLS_DTPMOD64', 0x405 => 'TLS_DTPREL64',
+			0x406 => 'TLS_TPREL64', 0x407 => 'TLSDESC' },
 	}
 
 	DEFAULT_INTERP = '/lib/ld-linux.so.2'
@@ -566,6 +614,7 @@ class ELF < ExeFormat
 
 	class SerialStruct
 		new_int_field :leb
+		new_int_field :uleb
 	end
 
 	# libdwarf/dwarf.h
@@ -629,6 +678,15 @@ class ELF < ExeFormat
 			end
 		end
 
+		class CIE < SerialStruct
+			attr_accessor :offset, :id, :version, :augmentation_string, :eh_data, :code_align,
+					:data_align, :return_reg, :augmentation_data, :initial_instrs
+		end
+
+		class FDE < SerialStruct
+			attr_accessor :offset, :cie_offset, :pc_begin, :pc_range, :augmentation_data, :instrs
+		end
+
 		word :cu_len
 		half :version, 2
 		word :abbrev_off
@@ -653,7 +711,7 @@ class ELF < ExeFormat
 		}
 	end
 
-	attr_accessor :header, :segments, :sections, :tag, :symbols, :relocations, :endianness, :bitsize, :debug
+	attr_accessor :header, :segments, :sections, :tag, :symbols, :relocations, :endianness, :bitsize, :debug, :eh_frame
 	def initialize(cpu=nil)
 		@header = Header.new
 		@tag = {}

data/metasm/exe_format/elf_decode.rb

@@ -781,13 +781,41 @@ class ELF
 			target = reloc_target(reloc)
 			target = Expression[target, :+, addend] if addend and addend != 0
 		else
-			puts "W: Elf: unhandled MIPS reloc #{reloc.inspect}" if $VERBOSE
+			puts "W: Elf: unhandled OpenRISC reloc #{reloc.inspect}" if $VERBOSE
 			target = nil
 		end
 
 		Metasm::Relocation.new(Expression[target], :u32, @endianness) if target
 	end
 
+	def arch_decode_segments_reloc_aarch64(reloc)
+		if reloc.symbol.kind_of?(Symbol) and n = reloc.symbol.name and reloc.symbol.shndx == 'UNDEF' and @sections and
+			s = @sections.find { |s_| s_.name and s_.offset <= @encoded.ptr and s_.offset + s_.size > @encoded.ptr }
+			@encoded.add_export(new_label("#{s.name}_#{n}"), @encoded.ptr, true)
+		end
+
+		original_xword = decode_xword
+
+		# decode addend if needed
+		case reloc.type
+		when 'NONE' # no addend
+		else addend = reloc.addend || Expression.make_signed(original_xword, 64)
+		end
+
+		case reloc.type
+		when 'NONE'
+		# TODO actual base relocs
+		when 'JUMP_SLOT'
+			target = reloc_target(reloc)
+			target = Expression[target, :+, addend] if addend and addend != 0
+		else
+			puts "W: Elf: unhandled AARCH64 reloc #{reloc.inspect}" if $VERBOSE
+			target = nil
+		end
+
+		Metasm::Relocation.new(Expression[target], :u64, @endianness) if target
+	end
+
 	class DwarfDebug
 		# decode a DWARF2 'compilation unit'
 		def decode(elf, info, abbrev, str)
@@ -850,19 +878,169 @@ class ELF
 				}
 			end
 		end
+
+		def self.decode_eh_frame_entry(elf, eh_frame)
+			start_ptr = eh_frame.ptr
+			len = elf.decode_word(eh_frame)
+			return if len == 0
+
+			if len >= 0xffff_fff0
+				puts "W: ELF: unhandled 64-bit .eh_frame entry"
+				return
+			end
+
+			id = elf.decode_word(eh_frame)
+			if id == 0
+				eh_frame.ptr = start_ptr
+				CIE.decode(elf, eh_frame)
+			else
+				eh_frame.ptr = start_ptr
+				FDE.decode(elf, eh_frame)
+			end
+		end
+
+		class CIE
+			def decode(elf, eh_frame)
+				@offset = eh_frame.ptr
+				len = elf.decode_word(eh_frame)
+				return if len == 0
+				return if len >= 0xffff_fff0
+				start_ptr = eh_frame.ptr
+
+				@id = elf.decode_word(eh_frame)
+				if id != 0
+					raise 'Not a CIE'	# FDE, decode_eh_frame_entry should have handled that
+				end
+				@version = elf.decode_byte(eh_frame)
+				@augmentation_string = elf.decode_strz(eh_frame)
+				if @augmentation_string.include?('eh')
+					@eh_data = elf.decode_xword(eh_frame)
+				end
+
+				@code_align = elf.decode_uleb(eh_frame)
+				@data_align = elf.decode_leb(eh_frame)
+				@return_reg = elf.decode_byte(eh_frame)
+
+				if @augmentation_string[0, 1] == 'z'
+					a_len = elf.decode_uleb(eh_frame)
+					@augmentation_data = eh_frame.read(a_len)
+					# 'L' => read_byte LSDA pointer encoding
+					# 'R' => read_byte FDE address encoding
+					# 'P' => read_encoded_value? personality routine
+				end
+
+				if eh_frame.ptr <= start_ptr + len
+					# DWARF opcodes
+					@initial_instrs = []
+					while eh_frame.ptr < start_ptr+len
+						@initial_instrs << DwarfDebug.decode_dw_cfa_op(elf, eh_frame)
+					end
+					@initial_instrs.pop while @initial_instrs.last == [:nop]
+				end
+
+				eh_frame.ptr = start_ptr + len
+			end
+		end
+
+		class FDE
+			def decode(elf, eh_frame)
+				@offset = eh_frame.ptr
+				len = elf.decode_word(eh_frame)
+				return if len == 0
+				return if len >= 0xffff_fff0
+				start_ptr = eh_frame.ptr
+
+				id = elf.decode_word(eh_frame)
+				if id == 0
+					raise 'Not an FDE'	# CIE
+				end
+				# in .eh_frame, this is a backward offset from current FDE to CIE, in .debug_frame, may be a direct offset from section start to CIE
+				@cie_offset = start_ptr - id
+				cie = elf.eh_frame.find { |c| c.offset == @cie_offset }
+
+				@pc_begin = Expression.make_signed(elf.decode_word(eh_frame), 32)
+				@pc_range = elf.decode_word(eh_frame)
+
+				if cie and cie.augmentation_data
+					a_len = elf.decode_uleb(eh_frame)
+					@augmentation_data = eh_frame.read(a_len)
+				end
+
+				if eh_frame.ptr <= start_ptr + len
+					# DWARF opcodes
+					@instrs = []
+					while eh_frame.ptr < start_ptr+len
+						@instrs << DwarfDebug.decode_dw_cfa_op(elf, eh_frame)
+					end
+					@instrs.pop while @instrs.last == [:nop]
+				end
+
+
+				eh_frame.ptr = start_ptr + len
+			end
+		end
+
+		# TODO make a cpu
+		def self.decode_dw_cfa_op(elf, eh_frame)
+			block = lambda {
+				blen = elf.decode_leb(eh_frame)
+				eh_frame.read(blen)
+			}
+
+			byte = elf.decode_byte(eh_frame)
+			case byte & 0xc0
+			when 0x40; [:advance_loc, byte & 0x3f]
+			when 0x80; [:offset, byte & 0x3f, elf.decode_uleb(eh_frame)]
+			when 0xc0; [:restore, byte & 0x3f]
+			else
+				case byte
+				when 0x00; [:nop]
+				when 0x01; [:set_loc, elf.decode_word(eh_frame)]
+				when 0x02; [:advance_loc, elf.decode_byte(eh_frame)]
+				when 0x03; [:advance_loc, elf.decode_half(eh_frame)]
+				when 0x04; [:advance_loc, elf.decode_word(eh_frame)]
+				when 0x05; [:offset_extended, elf.decode_uleb(eh_frame), elf.decode_uleb(eh_frame)]
+				when 0x06; [:restore_extended, elf.decode_uleb(eh_frame)]
+				when 0x07; [:undefined, elf.decode_uleb(eh_frame)]
+				when 0x08; [:same_value, elf.decode_uleb(eh_frame)]
+				when 0x09; [:register, elf.decode_uleb(eh_frame), elf.decode_uleb(eh_frame)]
+				when 0x0a; [:remember_state]
+				when 0x0b; [:restore_state]
+				when 0x0c; [:def_cfa, elf.decode_uleb(eh_frame), elf.decode_uleb(eh_frame)]
+				when 0x0d; [:def_cfa_register, elf.decode_uleb(eh_frame)]
+				when 0x0e; [:def_cfa_offset, elf.decode_uleb(eh_frame)]
+				when 0x0f; [:def_cfa_expression, block[]]
+				when 0x10; [:expression, elf.decode_uleb(eh_frame), block[]]
+				when 0x11; [:offset_extended_sf, elf.decode_uleb(eh_frame), elf.decode_leb(eh_frame)]
+				when 0x12; [:def_cfa_sf, elf.decode_uleb(eh_frame), elf.decode_leb(eh_frame)]
+				when 0x13; [:def_cfa_offset_sf, elf.decode_leb(eh_frame)]
+				when 0x14; [:val_offset, elf.decode_uleb(eh_frame), elf.decode_uleb(eh_frame)]
+				when 0x15; [:val_offset_sf, elf.decode_uleb(eh_frame), elf.decode_leb(eh_frame)]
+				when 0x16; [:val_expression, elf.decode_uleb(eh_frame), block[]]
+				when 0x1c; [:lo_user]
+				when 0x3f; [:hi_user]
+				else [byte]
+				end
+			end
+		end
 	end
 
 	# decode an ULEB128 (dwarf2): read bytes while high bit is set, littleendian
-	def decode_leb(ed = @encoded)
+	def decode_leb(ed = @encoded); decode_uleb(ed, true); end
+
+	def decode_uleb(ed, signed=false)
 		v = s = 0
-		loop {
+		while s < 10*7
 			b = ed.read(1).unpack('C').first.to_i
 			v |= (b & 0x7f) << s
 			s += 7
-			break v if (b&0x80) == 0
-		}
+			break if (b&0x80) == 0
+		end
+		v = Expression.make_signed(v, s) if signed
+		v
 	end
 
+
 	# decodes the debugging information if available
 	# only a subset of DWARF2/3 is handled right now
 	# most info taken from http://ratonland.org/?entry=39 & libdwarf/dwarf.h
@@ -887,6 +1065,23 @@ class ELF
 		end
 	end
 
+	def decode_eh_frame
+		return if not @sections
+
+		eh_frame = @sections.find { |sec| sec.name == '.eh_frame' }
+		return if not eh_frame
+
+		eh_frame = @encoded[eh_frame.offset, eh_frame.size]
+
+		@eh_frame = []
+
+		while eh_frame.ptr < eh_frame.length
+			entry = DwarfDebug.decode_eh_frame_entry(self, eh_frame)
+			break if not entry
+			@eh_frame << entry
+		end
+	end
+
 	# decodes the ELF dynamic tags, interpret them, and decodes symbols and relocs
 	def decode_segments_dynamic(decode_relocs=true)
 		return if not dynamic = @segments.find { |s| s.type == 'DYNAMIC' }
@@ -1067,7 +1262,7 @@ EOC
 				d.function[Expression[fn]] = noret
 			}
 			d.function[:default] = @cpu.disassembler_default_func
-		when 'openrisc'
+		when 'openrisc', 'arm64'
 			old_cp = d.c_parser
 			d.c_parser = nil
 			d.parse_c <<EOC

data/metasm/exe_format/shellcode.rb

@@ -114,5 +114,44 @@ class Shellcode < ExeFormat
 		}
 		c
 	end
+
+	# returns an assembly `db` directive for the given byte string
+	# example: define_data("ABCD".b) => 'db 0x41, 0x42, 0x43, 0x44'
+	# returns the empty string for empty input so callers can omit the directive
+	def self.define_data(bytes)
+		return '' if bytes.nil? || bytes.empty?
+
+		'db ' + bytes.each_byte.map { |b| '0x%02x' % b }.join(', ')
+	end
+
+	# returns an assembly `db` directive for a NULL-terminated string
+	# printable ASCII runs are emitted as string literals; non-printable bytes
+	# break the run and are emitted as hex tokens; a trailing 0 is always appended
+	# example: define_cstring("ABCD".b)      => 'db "ABCD", 0'
+	# example: define_cstring("AB\x05CD".b)  => 'db "AB", 0x05, "CD", 0'
+	# example: define_cstring("".b)          => 'db 0'
+	def self.define_cstring(str)
+		str = '' if str.nil?
+
+		parts = []
+		buf = String.new
+		flush = lambda {
+			unless buf.empty?
+				parts << '"' + buf.gsub(/[\\"]/) { |c| '\\' + c } + '"'
+				buf.clear
+			end
+		}
+		str.each_byte do |b|
+			if b >= 0x20 && b <= 0x7e
+				buf << b.chr
+			else
+				flush.call
+				parts << ('0x%02x' % b)
+			end
+		end
+		flush.call
+		parts << '0'
+		'db ' + parts.join(', ')
+	end
 end
 end

data/metasm/gui/dasm_decomp.rb

@@ -230,6 +230,7 @@ class CdecompListingWidget < DrawableWidget
 						# TODO _declspec
 						vt.args.to_a.each_with_index { |a, idx|
 							oa = curfunc.type.args.to_a[idx]
+							next if not oa
 							oa.misc ||= {}
 							a.misc ||= {}
 							uan = a.misc[:unalias_name] = oa.misc[:unalias_name] ||= oa.name

data/metasm/os/emulator.rb

@@ -31,6 +31,10 @@ class VirtualMemoryDasm < VirtualString
 		!@disassembler.get_section_at(addr)
 	end
 
+	def get_page(addr, len=@pagelength)
+		read_range(addr, len) if !page_invalid?(addr)
+	end
+
 	# overwrite a section of the file
 	def rewrite_at(addr, data)
 		if e = @disassembler.get_section_at(addr)
@@ -74,6 +78,7 @@ class EmuDebugger < Debugger
 		@breakpoint = {}
 		@breakpoint_memory = {}
 		@breakpoint_thread = {}
+		@cpu.initialize_emudbg(self) if @cpu.respond_to?(:initialize_emudbg)
 	end
 
 	def detach
@@ -160,9 +165,11 @@ class EmuDebugger < Debugger
 		}.each { |k, v|
 			case k
 			when Indirection
+				raise "cannot assign value #{v}" if not v.kind_of?(::Integer)
 				v = v & ((1 << (k.len*8)) - 1)
 				memory_write_int(k.pointer, v, k.len)
 			when Symbol
+				raise "cannot assign value #{v}" if not v.kind_of?(::Integer)
 				set_reg_value(k, v)
 			when /^dummy_metasm_/
 			else

data/metasm/parse_c.rb

@@ -3432,7 +3432,7 @@ EOH
 				oldc = nil
 				while c = dep_cycle[[t]]
 					break if oldc == c
-					r << CRenderString.new(t, "#{t.kind_of?(Struct) ? 'struct' : 'union'} #{t.name};") if not oldc
+					r << "#{t.kind_of?(Struct) ? 'struct' : 'union'} #{t.name};" if not oldc
 					oldc = c
 					c.each { |s|
 						# XXX struct z { struct a* }; struct a { void (*foo)(struct z); };

data/metasm.gemspec

@@ -4,7 +4,7 @@ require 'metasm'
 
 Gem::Specification.new do |s|
   s.name          = 'metasm'
-  s.version       = '1.0.4'
+  s.version       = '1.0.6'
   s.summary       =
     "Metasm is a cross-architecture assembler, disassembler, linker, and debugger."
   s.description   = ""
@@ -16,7 +16,6 @@ Gem::Specification.new do |s|
   s.homepage      = 'http://metasm.cr0.org'
   s.license       = 'LGPL-2.1'
 
-  s.add_development_dependency "bundler", "~> 1.7"
   s.add_development_dependency "rake"
   s.add_development_dependency "test-unit"
 end

data/metasm.rb

@@ -38,7 +38,7 @@ module Metasm
 		'X86_64' => 'cpu/x86_64', 'Sh4' => 'cpu/sh4', 'Dalvik' => 'cpu/dalvik', 'ARC' => 'cpu/arc',
 		'Python' => 'cpu/python', 'Z80' => 'cpu/z80', 'CY16' => 'cpu/cy16', 'BPF' => 'cpu/bpf', 'EBPF' => 'cpu/ebpf',
 		'MSP430' => 'cpu/msp430', 'ARM64' => 'cpu/arm64', 'ST20' => 'cpu/st20', 'MCS51' => 'cpu/mcs51',
-		'OpenRisc' => 'cpu/openrisc', 'WebAsm' => 'cpu/webasm',
+		'OpenRisc' => 'cpu/openrisc', 'WebAsm' => 'cpu/webasm', 'Dwarf' => 'cpu/dwarf',
 		'C' => 'compile_c',
 		'MZ' => 'exe_format/mz', 'PE' => 'exe_format/pe',
 		'ELF' => 'exe_format/elf', 'COFF' => 'exe_format/coff',

data/samples/disassemble-gui.rb

@@ -25,12 +25,13 @@
 #
 
 require 'metasm'
+include Metasm
 require 'optparse'
 
 $VERBOSE = true
 
 # parse arguments
-opts = { :sc_cpu => 'Ia32' }
+opts = {}
 OptionParser.new { |opt|
 	opt.banner = 'Usage: disassemble-gtk.rb [options] <executable> [<entrypoints>]'
 	opt.on('--no-data-trace', 'do not backtrace memory read/write accesses') { opts[:nodatatrace] = true }
@@ -54,31 +55,42 @@ OptionParser.new { |opt|
 	opt.on('-A', '--disassemble-all-entrypoints') { opts[:dasm_all] = true }
 }.parse!(ARGV)
 
+opts[:sc_cpu] = eval(opts[:sc_cpu]) if opts[:sc_cpu] =~ /[.(\s:]/
+opts[:sc_cpu] = Metasm.const_get(opts[:sc_cpu]) if opts[:sc_cpu].kind_of?(::String)
+opts[:sc_cpu] = opts[:sc_cpu].new if opts[:sc_cpu].kind_of?(::Class)
+opts[:exe_fmt] = eval(opts[:exe_fmt]) if opts[:exe_fmt] =~ /[.(\s:]/
+
 case exename = ARGV.shift
 when /^live:(.*)/
 	t = $1
 	t = t.to_i if $1 =~ /^[0-9]+$/
-	os = Metasm::OS.current
+	os = OS.current
 	raise 'no such target' if not target = os.find_process(t) || os.create_process(t)
 	p target if $VERBOSE
-	w = Metasm::Gui::DbgWindow.new(target.debugger, "#{target.pid}:#{target.modules[0].path rescue nil} - metasm debugger")
+	w = Gui::DbgWindow.new(target.debugger, "#{target.pid}:#{target.modules[0].path rescue nil} - metasm debugger")
 	dbg = w.dbg_widget.dbg
+when /^emu:(.*)/
+	t = $1
+	exefmt = opts[:exe_fmt] || AutoExe.orshellcode { opts[:sc_cpu] || Ia32.new }
+	dbgexe = exefmt.decode_file(t)
+	dbgexe.cpu = opts[:sc_cpu] if opts[:sc_cpu]
+	dbg = EmuDebugger.new(dbgexe.disassembler)
+	w = Gui::DbgWindow.new(dbg, "emudbg")
 when /^(tcp:|udp:)?..+:/
-	dbg = Metasm::GdbRemoteDebugger.new(exename, opts[:sc_cpu])
-	w = Metasm::Gui::DbgWindow.new(dbg, "remote - metasm debugger")
+	dbg = GdbRemoteDebugger.new(exename, opts[:sc_cpu] || Ia32.new)
+	w = Gui::DbgWindow.new(dbg, "remote - metasm debugger")
 else
-	w = Metasm::Gui::DasmWindow.new("#{exename + ' - ' if exename}metasm disassembler")
+	w = Gui::DasmWindow.new("#{exename + ' - ' if exename}metasm disassembler")
 	if exename
-		opts[:sc_cpu] = eval(opts[:sc_cpu]) if opts[:sc_cpu] =~ /[.(\s:]/
-		opts[:exe_fmt] = eval(opts[:exe_fmt]) if opts[:exe_fmt] =~ /[.(\s:]/
-		exe = w.loadfile(exename, opts[:sc_cpu], opts[:exe_fmt])
+		exe = w.loadfile(exename, opts[:sc_cpu] || 'Ia32', opts[:exe_fmt])
+		exe.disassembler.cpu = exe.cpu = opts[:sc_cpu] if opts[:sc_cpu]
 		exe.disassembler.rebase(opts[:rebase]) if opts[:rebase]
 		if opts[:autoload]
 			basename = exename.sub(/\.\w\w?\w?$/, '')
 			opts[:map] ||= basename + '.map' if File.exist?(basename + '.map')
 			opts[:cheader] ||= basename + '.h' if File.exist?(basename + '.h')
 			(opts[:plugin] ||= []) << (basename + '.rb') if File.exist?(basename + '.rb')
-			opts[:session] ||= basename + '.metasm-session'
+			opts[:session] ||= basename + '.metasm-session' if File.exist?(basename + '.metasm-session')
 		end
 	end
 end
@@ -104,6 +116,10 @@ elsif dbg
 			puts "Error with plugin #{p}: #{$!.class} #{$!}"
 		end
 	}
+	if exename[0, 4] == 'emu:' and ep.first
+		dbg.pc = ep.first
+		w.dbg_widget.code.focus_addr dbg.pc
+	end
 end
 
 if dasm
@@ -139,5 +155,5 @@ end
 
 opts[:hookstr].to_a.each { |f| eval f }
 
-Metasm::Gui.main
+Gui.main
 

data/samples/disassemble.rb

@@ -15,7 +15,7 @@ include Metasm
 require 'optparse'
 
 # parse arguments
-opts = { :sc_cpu => 'Ia32' }
+opts = {}
 OptionParser.new { |opt|
 	opt.banner = 'Usage: disassemble.rb [options] <executable> [<entrypoints>]'
 	opt.on('--no-data', 'do not display data bytes') { opts[:nodata] = true }
@@ -44,28 +44,25 @@ exename = ARGV.shift
 
 t0 = Time.now if opts[:benchmark]
 
+opts[:sc_cpu] = eval(opts[:sc_cpu]) if opts[:sc_cpu] =~ /[.(\s:]/
+opts[:sc_cpu] = Metasm.const_get(opts[:sc_cpu]) if opts[:sc_cpu].kind_of?(::String)
+opts[:sc_cpu] = opts[:sc_cpu].new if opts[:sc_cpu].kind_of?(::Class)
+
 # load the file
 if exename =~ /^live:(.*)/
 	raise 'no such live target' if not target = OS.current.find_process($1)
 	p target if $VERBOSE
-	opts[:sc_cpu] = eval(opts[:sc_cpu]) if opts[:sc_cpu] =~ /[.(\s:]/
-	opts[:sc_cpu] = Metasm.const_get(opts[:sc_cpu]) if opts[:sc_cpu].kind_of(::String)
-	opts[:sc_cpu] = opts[:sc_cpu].new if opts[:sc_cpu].kind_of?(::Class)
-	exe = Shellcode.decode(target.memory, opts[:sc_cpu])
+	exe = Shellcode.decode(target.memory, opts[:sc_cpu] || Ia32.new)
 else
-	opts[:sc_cpu] = eval(opts[:sc_cpu]) if opts[:sc_cpu] =~ /[.(\s:]/
 	opts[:exe_fmt] = eval(opts[:exe_fmt]) if opts[:exe_fmt] =~ /[.(\s:]/
 	if opts[:exe_fmt].kind_of?(::String)
 		exefmt = opts[:exe_fmt] = Metasm.const_get(opts[:exe_fmt])
 	else
-		exefmt = opts[:exe_fmt] || AutoExe.orshellcode {
-			opts[:sc_cpu] = Metasm.const_get(opts[:sc_cpu]) if opts[:sc_cpu].kind_of?(::String)
-			opts[:sc_cpu] = opts[:sc_cpu].new if opts[:sc_cpu].kind_of?(::Class)
-			opts[:sc_cpu]
-		}
+		exefmt = opts[:exe_fmt] || AutoExe.orshellcode { opts[:sc_cpu] || Ia32.new }
 	end
-	exefmt = exefmt.withcpu(opts[:sc_cpu]) if exefmt.kind_of?(::Class) and exefmt.name.to_s.split('::').last == 'Shellcode'
+	exefmt = exefmt.withcpu(opts[:sc_cpu] || Ia32.new) if exefmt.kind_of?(::Class) and exefmt.name.to_s.split('::').last == 'Shellcode'
 	exe = exefmt.decode_file(exename)
+	exe.cpu = opts[:sc_cpu] if opts[:sc_cpu]
 	exe.disassembler.rebase(opts[:rebase]) if opts[:rebase]
 	if opts[:autoload]
 		basename = exename.sub(/\.\w\w?\w?$/, '')

data/samples/emudbg.rb

@@ -84,7 +84,7 @@ pkt = EncodedData.new(eth + ip + udp + pld)
 dasm.add_section(pkt, 0x9000)
 
 # Initialize the emulator
-dbg = Metasm::EmuDebugger.new(dasm)
+dbg = EmuDebugger.new(dasm)
 # Set the initial state of the registers
 dbg.set_reg_value(:r10, 0x8900)
 # :packet is a special register used internally by some opcodes of the EBPF cpu (packet data store/load)

data/samples/factorize-headers-elfimports.rb

@@ -36,6 +36,9 @@ when ELF
 	funcnames = exe.symbols.map { |s| s.name if s.shndx == 'UNDEF' and s.type == 'FUNC' }
 	opts[:hdrs] << 'stdio.h' << 'stdlib.h' << 'unistd.h'
 	opts[:gcc] = true if not opts[:vs]
+	case exe.cpu.shortname
+	when 'x64'; opts[:path] << '/usr/include/x86_64-linux-gnu/'
+	end
 else raise "unsupported #{exe.class}"
 end
 
@@ -51,7 +54,7 @@ ARGV.each { |n|
 
 src = opts[:hdrs].map { |h| "#include <#{h}>" }.join("\n")
 
-parser = Ia32.new.new_cparser
+parser = exe.cpu.new_cparser
 parser.prepare_gcc if opts[:gcc]
 parser.prepare_visualstudio if opts[:vs]
 pp = parser.lexer

data/samples/lindebug.rb

@@ -357,6 +357,7 @@ class LinDebug
 				   raw[8,8].to_s.unpack('C*').map { |c| '%02x ' % c }.join
 			when 'dw'; text << raw.unpack('S*').map { |c| '%04x ' % c }.join
 			when 'dd'; text << raw.unpack('L*').map { |c| '%08x ' % c }.join
+			when 'dq'; text << raw.unpack('Q*').map { |c| '%016x ' % c }.join
 			end
 			text << ' ' << raw.unpack('C*').map { |c| (0x20..0x7e).include?(c) ? c : 0x2e }.pack('C*')
 			text << Ansi::ClearLineAfter << "\n"
@@ -655,6 +656,7 @@ class LinDebug
 		@command['db'] = lambda { |str| @datafmt = 'db' ; @dataptr = @dbg.resolve(str) if str.length > 0 }
 		@command['dw'] = lambda { |str| @datafmt = 'dw' ; @dataptr = @dbg.resolve(str) if str.length > 0 }
 		@command['dd'] = lambda { |str| @datafmt = 'dd' ; @dataptr = @dbg.resolve(str) if str.length > 0 }
+		@command['dq'] = lambda { |str| @datafmt = 'dq' ; @dataptr = @dbg.resolve(str) if str.length > 0 }
 		@command['r'] =  lambda { |str|
 			r, str = str.split(/\s+/, 2)
 			if r == 'fl'
@@ -700,17 +702,29 @@ end
 
 if $0 == __FILE__
 	require 'optparse'
-	opts = { :sc_cpu => 'Ia32' }
+	opts = {}
 	OptionParser.new { |opt|
 		opt.on('-m map', '--map filemap') { |f| opts[:filemap] = f }
 		opt.on('--cpu cpu') { |c| opts[:sc_cpu] = c }
 	}.parse!(ARGV)
 
 	case ARGV.first
+	when /^emu:(.*)/
+		exepath = $1
+		opts[:sc_cpu] = eval(opts[:sc_cpu]) if opts[:sc_cpu] =~ /[.(\s:]/
+		opts[:sc_cpu] = Metasm.const_get(opts[:sc_cpu]) if opts[:sc_cpu].kind_of?(::String)
+		opts[:sc_cpu] = opts[:sc_cpu].new if opts[:sc_cpu].kind_of?(::Class)
+		exe = Metasm::AutoExe.orshellcode { opts[:sc_cpu] || Metasm::Ia32.new }.decode_file(exepath)
+		exe.cpu = opts[:sc_cpu] if opts[:sc_cpu]
+		dbg = Metasm::EmuDebugger.new(exe.disassembler)
+		if ARGV[1]
+			dbg.pc = Integer(ARGV[1])
+		end
 	when /^(tcp:|udp:)?..+:/, /^ser:/
 		opts[:sc_cpu] = eval(opts[:sc_cpu]) if opts[:sc_cpu] =~ /[.(\s:]/
+		opts[:sc_cpu] = Metasm.const_get(opts[:sc_cpu]) if opts[:sc_cpu].kind_of?(::String)
 		opts[:sc_cpu] = opts[:sc_cpu].new if opts[:sc_cpu].kind_of?(::Class)
-		dbg = Metasm::GdbRemoteDebugger.new(ARGV.first, opts[:sc_cpu])
+		dbg = Metasm::GdbRemoteDebugger.new(ARGV.first, opts[:sc_cpu] || Metasm::Ia32.new)
 	else
 		dbg = Metasm::LinDebugger.new(ARGV.join(' '))
 	end