metasm 1.0.0

data/lib/metasm/exe_format/main.rb

@@ -0,0 +1,228 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2006-2009 Yoann GUILLOT
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+
+require 'metasm/main'
+require 'metasm/parse'
+require 'metasm/encode'
+require 'metasm/decode'
+require 'metasm/exe_format/serialstruct'
+require 'metasm/os/main'	# VirtualFile
+
+module Metasm
+class ExeFormat
+	# creates a new instance, populates self.encoded with the supplied string
+	def self.load(str, *a, &b)
+		e = new(*a, &b)
+		if str.kind_of? EncodedData; e.encoded = str
+		else e.encoded << str
+		end
+		e
+	end
+
+	# same as load, used by AutoExe
+	def self.autoexe_load(*x, &b)
+		load(*x, &b)
+	end
+
+	attr_accessor :filename
+
+	# same as +load+, but from a file
+	# uses VirtualFile if available
+	def self.load_file(path, *a, &b)
+		e = load(VirtualFile.read(path), *a, &b)
+		e.filename ||= path
+		e
+	end
+
+	# +load_file+ then decode
+	def self.decode_file(path, *a, &b)
+		e = load_file(path, *a, &b)
+		e.decode if not e.instance_variables.map { |iv| iv.to_s }.include?("@disassembler")
+		e
+	end
+
+	# +load_file+ then decode header
+	def self.decode_file_header(path, *a, &b)
+		e = load_file(path, *a, &b)
+		e.decode_header
+		e
+	end
+
+	def self.decode(raw, *a, &b)
+		e = load(raw, *a, &b)
+		e.decode
+		e
+	end
+
+	def self.decode_header(raw, *a, &b)
+		e = load(raw, *a, &b)
+		e.decode_header
+		e
+	end
+
+	# creates a new object using the specified cpu, parses the asm source, and assemble
+	def self.assemble(cpu, source, file='<unk>', lineno=1)
+		source, cpu = cpu, source if source.kind_of? CPU
+		e = new(cpu)
+		e.assemble(source, file, lineno)
+		e
+	end
+
+	# same as #assemble, reads asm source from the specified file
+	def self.assemble_file(cpu, filename)
+		filename, cpu = cpu, filename if filename.kind_of? CPU
+		assemble(cpu, File.read(filename), filename, 1)
+	end
+
+	# parses a bunch of standalone C code, compile and assemble it
+	def compile_c(source, file='<unk>', lineno=1)
+		cp = @cpu.new_cparser
+		tune_cparser(cp)
+		cp.parse(source, file, lineno)
+		read_c_attrs cp if respond_to? :read_c_attrs
+		asm_source = @cpu.new_ccompiler(cp, self).compile
+		puts asm_source if $DEBUG
+		assemble(asm_source, 'C compiler output', 1)
+		c_set_default_entrypoint
+	end
+
+	# creates a new object using the specified cpu, parse/compile/assemble the C source
+	def self.compile_c(cpu, source, file='<unk>', lineno=1)
+		source, cpu = cpu, source if source.kind_of? CPU
+		e = new(cpu)
+		e.compile_c(source, file, lineno)
+		e
+	end
+
+	def self.compile_c_file(cpu, filename)
+		filename, cpu = cpu, filename if filename.kind_of? CPU
+		compile_c(cpu, File.read(filename), filename, 1)
+	end
+
+	# add directive to change the current assembler section to the assembler source +src+
+	def compile_setsection(src, section)
+		src << section
+	end
+
+	# prepare a preprocessor before it reads any source, should define macros to identify the fileformat
+	def tune_prepro(l)
+	end
+
+	# prepare a cparser
+	def tune_cparser(cp)
+		tune_prepro(cp.lexer)
+	end
+
+	# this is called once C code is parsed, to handle C attributes like export/import/init etc
+	def read_c_attrs(cp)
+	end
+
+	# should setup a default entrypoint for C code, including preparing args for main() etc
+	def c_set_default_entrypoint
+	end
+
+	attr_writer :disassembler	# custom reader
+	def disassembler
+		@disassembler ||= init_disassembler
+	end
+
+	# returns the exe disassembler
+	# if it does not exist, creates one, and feeds it with the exe sections
+	def init_disassembler
+		@disassembler ||= Disassembler.new(self)
+		@disassembler.cpu ||= cpu
+		each_section { |edata, base|
+			edata ||= EncodedData.new
+			@disassembler.add_section edata, base
+		}
+		@disassembler
+	end
+
+	# disassembles the specified entrypoints
+	# initializes the disassembler if needed
+	# uses get_default_entrypoints if the argument list is empty
+	# returns the disassembler
+	def disassemble(*entrypoints)
+		entrypoints = get_default_entrypoints if entrypoints.empty?
+		disassembler.disassemble(*entrypoints)
+		@disassembler
+	end
+
+	# disassembles the specified entrypoints without backtracking
+	# initializes the disassembler if needed
+	# uses get_default_entrypoints if the argument list is empty
+	# returns the disassembler
+	def disassemble_fast_deep(*entrypoints)
+		entrypoints = get_default_entrypoints if entrypoints.empty?
+		disassembler.disassemble_fast_deep(*entrypoints)
+		@disassembler
+	end
+
+	# returns a list of entrypoints to disassemble (program entrypoint, exported functions...)
+	def get_default_entrypoints
+		[]
+	end
+
+	# encodes the executable as a string, checks that all relocations are
+	# resolved, and returns the raw string version
+	def encode_string(*a)
+		encode(*a)
+		raise ["Unresolved relocations:", @encoded.reloc.map { |o, r| "#{r.target} " + (Backtrace.backtrace_str(r.backtrace) if r.backtrace).to_s }].join("\n") if not @encoded.reloc.empty?
+		@encoded.data
+	end
+
+	# saves the result of +encode_string+ in the specified file
+	# fails if the file already exists
+	def encode_file(path, *a)
+		#raise Errno::EEXIST, path if File.exist? path	# race, but cannot use O_EXCL, as O_BINARY is not defined in ruby
+		encode_string(*a)
+		File.open(path, 'wb') { |fd| fd.write(@encoded.data) }
+	end
+
+	# returns the address at which a given file offset would be mapped
+	def addr_to_fileoff(addr)
+		addr
+	end
+
+	# returns the file offset where a mapped byte comes from
+	def fileoff_to_addr(foff)
+		foff
+	end
+
+	def shortname; self.class.name.split('::').last.downcase; end
+
+module IntToHash
+	# converts a constant name to its numeric value using the hash
+	# {1 => 'toto', 2 => 'tata'}: 'toto' => 1, 42 => 42, 'tutu' => raise
+	def int_from_hash(val, hash)
+		val.kind_of?(Integer) ? hash.index(val) || val : hash.index(val) or raise "unknown constant #{val.inspect}"
+	end
+
+	# converts an array of flag constants to its numeric value using the hash
+	# {1 => 'toto', 2 => 'tata'}: ['toto', 'tata'] => 3, 'toto' => 2, 42 => 42
+	def bits_from_hash(val, hash)
+		val.kind_of?(Array) ? val.inject(0) { |val_, bitname| val_ | int_from_hash(bitname, hash) } : int_from_hash(val, hash)
+	end
+
+	# converts a numeric value to the corresponding constant name using the hash
+	# {1 => 'toto', 2 => 'tata'}: 1 => 'toto', 42 => 42, 'tata' => 'tata', 'tutu' => raise
+	def int_to_hash(val, hash)
+		val.kind_of?(Integer) ? hash.fetch(val, val) : (hash.index(val) ? val : raise("unknown constant #{val.inspect}"))
+	end
+
+	# converts a numeric value to the corresponding array of constant flag names using the hash
+	# {1 => 'toto', 2 => 'tata'}: 5 => ['toto', 4]
+	def bits_to_hash(val, hash)
+		(val.kind_of?(Integer) ? (hash.find_all { |k, v| val & k == k and val &= ~k }.map { |k, v| v } << val) : val.kind_of?(Array) ? val.map { |e| int_to_hash(e, hash) } : [int_to_hash(val, hash)]) - [0]
+	end
+end
+	include IntToHash
+end
+
+class SerialStruct
+	include ExeFormat::IntToHash
+end
+end

data/lib/metasm/exe_format/mz.rb

@@ -0,0 +1,164 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2006-2009 Yoann GUILLOT
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+
+require 'metasm/exe_format/main'
+require 'metasm/encode'
+require 'metasm/decode'
+
+module Metasm
+class MZ < ExeFormat
+	MAGIC = 'MZ'	# 0x4d5a
+	class Header < SerialStruct
+		mem :magic, 2, MAGIC
+		words :cblp, :cp, :crlc, :cparhdr, :minalloc, :maxalloc, :ss, :sp, :csum, :ip, :cs, :lfarlc, :ovno
+		mem :unk, 4
+
+		def encode(mz, relocs)
+			h = EncodedData.new
+			set_default_values mz, h, relocs
+			h << super(mz)
+		end
+
+		def set_default_values(mz, h=nil, relocs=nil)
+			return if not h
+			@cblp     ||= Expression[[mz.label_at(mz.body, mz.body.virtsize), :-, mz.label_at(h, 0)], :%, 512]	# number of bytes used in last page
+			@cp       ||= Expression[[mz.label_at(mz.body, mz.body.virtsize), :-, mz.label_at(h, 0)], :/, 512]	# number of pages used
+			@crlc     ||= relocs.virtsize/4
+			@cparhdr  ||= Expression[[mz.label_at(relocs, 0), :-, mz.label_at(h, 0)], :/, 16]	# header size in paragraphs (16o)
+			@minalloc ||= ((mz.body.virtsize - mz.body.rawsize) + 15) / 16
+			@maxalloc ||= @minalloc
+			@sp       ||= 0		# ss:sp points at 1st byte of body => works if body does not reach end of segment (or maybe the overflow make the stack go to header space)
+			@lfarlc   ||= Expression[mz.label_at(relocs, 0), :-, mz.label_at(h, 0)]
+
+			super(mz)
+		end
+
+		def decode(mz)
+			super(mz)
+			raise InvalidExeFormat, "Invalid MZ signature #{h.magic.inspect}" if @magic != MAGIC
+		end
+	end
+
+	class Relocation < SerialStruct
+		words :offset, :segment
+	end
+
+
+	# encodes a word in 16 bits
+	def encode_word(val)        Expression[val].encode(:u16, @endianness) end
+	# decodes a 16bits word from self.encoded
+	def decode_word(edata = @encoded) edata.decode_imm(:u16, @endianness) end
+
+
+	attr_accessor :endianness, :header, :source
+	# the EncodedData representing the content of the file
+	attr_accessor :body
+	# an array of Relocations - quite obscure
+	attr_accessor :relocs
+
+	def initialize(cpu=nil)
+		@endianness = cpu ? cpu.endianness : :little
+		@relocs = []
+		@header = Header.new
+		@body = EncodedData.new
+		@source = []
+		super(cpu)
+	end
+
+	# assembles the source in the body, clears the source
+	def assemble(*a)
+		parse(*a) if not a.empty?
+		@body << assemble_sequence(@source, @cpu)
+		@body.fixup @body.binding
+		# XXX should create @relocs here
+		@source.clear
+	end
+
+	# sets up @cursource
+	def parse_init
+		@cursource = @source
+		super()
+	end
+
+	# encodes the header and the relocation table, return them in an array, with the body.
+	def pre_encode
+		relocs = @relocs.inject(EncodedData.new) { |edata, r| edata << r.encode(self) }
+		header = @header.encode self, relocs
+		[header, relocs, @body]
+	end
+
+	# defines the exe-specific parser instructions:
+	# .entrypoint [<label>]: defines the program entrypoint to label (or create a new label at this location)
+	def parse_parser_instruction(instr)
+		case instr.raw.downcase
+		when '.entrypoint'
+			# ".entrypoint <somelabel/expression>" or ".entrypoint" (here)
+			@lexer.skip_space
+			if tok = @lexer.nexttok and tok.type == :string
+				raise instr, 'syntax error' if not entrypoint = Expression.parse(@lexer)
+			else
+				entrypoint = new_label('entrypoint')
+				@cursource << Label.new(entrypoint, instr.backtrace.dup)
+			end
+			@header.ip = Expression[entrypoint, :-, label_at(@body, 0, 'body')]
+			@lexer.skip_space
+			raise instr, 'eol expected' if t = @lexer.nexttok and t.type != :eol
+		end
+	end
+
+
+	# concats the header, relocation table and body
+	def encode
+		pre_encode.inject(@encoded) { |edata, pe| edata << pe }
+		@encoded.fixup @encoded.binding
+		encode_fix_checksum
+	end
+
+	# sets the file checksum (untested)
+	def encode_fix_checksum
+		@encoded.ptr = 0
+		decode_header
+		mzlen = @header.cp * 512 + @header.cblp
+		@encoded.ptr = 0
+		csum = -@header.csum
+		(mzlen/2).times { csum += decode_word }
+		csum &= 0xffff
+		@header.csum = csum
+		hdr = @header.encode(self, nil)
+		@encoded[0, hdr.length] = hdr
+	end
+
+	# decodes the MZ header from the current offset in self.encoded
+	def decode_header
+		@header.decode self
+	end
+
+	# decodes the relocation table
+	def decode_relocs
+		@relocs.clear
+		@encoded.ptr = @header.lfarlc
+		@header.crlc.times { @relocs << Relocation.decode(self) }
+	end
+
+	# decodes the main part of the program
+	# mostly defines the 'start' export, to point to the MZ entrypoint
+	def decode_body
+		@body = @encoded[@header.cparhdr*16...@header.cp*512+@header.cblp]
+		@body.virtsize += @header.minalloc * 16
+		@body.add_export 'start', @header.cs * 16 + @header.ip
+	end
+
+	def decode
+		decode_header
+		decode_relocs
+		decode_body
+	end
+
+	def each_section
+		yield @body, 0
+	end
+end
+end

data/lib/metasm/exe_format/nds.rb

@@ -0,0 +1,172 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2006-2009 Yoann GUILLOT
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+
+require 'metasm/exe_format/main'
+require 'metasm/encode'
+require 'metasm/decode'
+
+
+module Metasm
+# Nintendo DS executable file format
+class NDS < ExeFormat
+	class Header < SerialStruct
+		str :title, 12
+		str :code, 4
+		str :maker, 2
+		bytes :unitcode, :encryptionselect, :devicetype
+		mem :reserved1, 9
+		bytes :version, :autostart
+		words :arm9off, :arm9entry, :arm9addr, :arm9sz
+		words :arm7off, :arm7entry, :arm7addr, :arm7sz
+		words :fnameoff, :fnamesz, :fatoff, :fatsz
+		words :arm9oloff, :arm9olsz, :arm7oloff, :arm7olsz
+		words :romctrl1, :romtcrl2, :iconoff
+		half :secureCRC
+		half :romctrl3
+		words :a9autoloadlist, :a7autoloadlist
+		mem :secareadisable, 8
+		words :endoff, :headersz
+		mem :reserved4, 56
+	       	mem :ninlogo, 156
+		half :logoCRC, 0xcf56
+		half :headerCRC
+	end
+
+	class Icon < SerialStruct
+		halfs :version, :crc
+		mem :reserved, 0x1c
+		mem :bitmap, 0x200	# 32x32, 4x4 tiles, each 4x8 bytes, 4bit depth
+		mem :palette, 0x20	# 16 colocs 16bits 0..0x7fff, 0 transparent (ignored)
+		mem :title_jap, 0x100	# 16bit unicode
+		mem :title_eng, 0x100
+		mem :title_fre, 0x100
+		mem :title_ger, 0x100
+		mem :title_ita, 0x100
+		mem :title_spa, 0x100
+		mem :unused, 0x1c0
+
+		attr_accessor :title_jap_short, :title_eng_short, :title_fre_short, :title_ger_short, :title_ita_short, :title_spa_short
+
+		def decode(exe)
+			super(exe)
+
+			%w[jap eng fre ger ita spa].each { |lang|
+				str = instance_variable_get("@title_#{lang}")
+				uchrs = str.unpack('v*')
+				str = str[0, uchrs.index(?\0).to_i*2]
+				instance_variable_set("@title_#{lang}", str)
+				str = str.unpack('v*').pack('C*')
+				instance_variable_set("@title_#{lang}_short", str)
+			}
+		end
+	end
+
+	def encode_byte(val) Expression[val].encode(:u8,  @endianness) end
+	def encode_half(val) Expression[val].encode(:u16, @endianness) end
+	def encode_word(val) Expression[val].encode(:u32, @endianness) end
+	def decode_byte(edata = @encoded) edata.decode_imm(:u8,  @endianness) end
+	def decode_half(edata = @encoded) edata.decode_imm(:u16, @endianness) end
+	def decode_word(edata = @encoded) edata.decode_imm(:u32, @endianness) end
+
+
+	attr_accessor :header, :icon, :arm9, :arm7
+	attr_accessor :files, :fat
+
+	def initialize(endianness=:little)
+		@endianness = endianness
+		@encoded = EncodedData.new
+	end
+
+	# decodes the header from the current offset in self.encoded
+	def decode_header
+		@header = Header.decode(self)
+	end
+
+	def decode_icon
+		@encoded.ptr = @header.iconoff
+		@icon = Icon.decode(self)
+	end
+
+	def decode
+		decode_header
+		decode_icon
+		@arm9 = @encoded[@header.arm9off, @header.arm9sz]
+		@arm7 = @encoded[@header.arm7off, @header.arm7sz]
+		@arm9.add_export('entrypoint', @header.arm9entry - @header.arm9addr)
+		@arm7.add_export('entrypoint_arm7', @header.arm7entry - @header.arm7addr)
+	end
+
+	def decode_fat
+		# decode the files section
+		# it is just the tree structure of a file hierarchy
+		# no indication whatsoever on where to find individual file content
+		f = @encoded[@fnameoff, @fnamesz]
+		f.ptr = 0
+		idx = []
+		# 1st word = size of index subsection
+		idxsz = decode_word(f)
+		f.ptr = 0
+		# index seems to be an array of word, half, half (offset of name, index of name of first file, index of name of first subdir)
+		(idxsz/8).times { idx << [decode_word(f), decode_half(f), decode_half(f)] }
+		# follows a serie of filenames : 1-byte length, name
+		# if length has high bit set, name is a directory, content = index[half following the name]
+		dat = []
+		idx.each { |off, idf, idd|
+			f.ptr = off
+			dat << []
+			while (l = decode_byte(f)) > 0
+				name = f.read(l&0x7f)
+				if l & 0x80 > 0
+					i = decode_half(f)
+					dat.last << { name => i.to_s(16) }
+				else
+					dat.last << name
+				end
+			end
+		}
+
+		# build the tree from the serialized data
+		# directory = array of [hash (subdirname => directory) or string (filename)]
+		tree = dat.map { |dt| dt.map { |d| d.dup } }
+		tree.each { |br|
+			br.grep(Hash).each { |b|
+				b.each { |k, v| b[k] = tree[v.to_i(16) & 0xfff] }
+			}
+		}
+		tree = tree.first
+
+		# flatten the tree to a list of fullpath
+		iter = lambda { |ar, cur|
+			ret = []
+			ar.each { |elem|
+				case elem
+				when Hash; ret.concat iter[elem.values.first, cur + elem.keys.first + '/']
+				else ret << (cur + elem)
+				end
+			}
+			ret
+		}
+
+		@files = tree #iter[tree, '/']
+
+		encoded.ptr = @fatoff
+		@fat = encoded.read(@fatsz)
+	end
+
+	def cpu_from_headers
+		ARM.new
+	end
+
+	def each_section
+		yield @arm9, @header.arm9addr
+		yield @arm7, @header.arm7addr
+	end
+
+	def get_default_entrypoints
+		[@header.arm9entry, @header.arm7entry]
+	end
+end
+end