metasm 1.0.0

data/lib/metasm/encode.rb

@@ -0,0 +1,333 @@
+#    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'
+
+module Metasm
+class ExeFormat
+	# encodes an Array of source (Label/Data/Instruction etc) to an EncodedData
+	# resolves ambiguities using +encode_resolve+
+	def assemble_sequence(seq, cpu)
+		# an array of edata or sub-array of ambiguous edata
+		# its last element is always an edata
+		ary = [EncodedData.new]
+
+		seq.each { |e|
+			case e
+			when Label; ary.last.add_export(e.name, ary.last.virtsize)
+			when Data;  ary.last << e.encode(cpu.endianness)
+			when Align, Padding
+				e.fillwith = e.fillwith.encode(cpu.endianness) if e.fillwith and not e.fillwith.kind_of? EncodedData
+				ary << e << EncodedData.new
+			when Offset; ary << e << EncodedData.new
+			when Instruction
+				case i = cpu.encode_instruction(self, e)
+				when Array
+					case i.length
+					when 0; raise EncodeError, "failed to encode #{e}"
+					when 1; ary.last << i.first
+					else ary << i << EncodedData.new # to solve later
+					end
+				else
+					ary.last << i
+				end
+			end
+		}
+
+		edata = (ary.length > 1) ? assemble_resolve(ary) : ary.shift
+		edata.fixup edata.binding
+		edata
+	end
+
+	# chose among multiple possible sub-EncodedData
+	# assumes all ambiguous edata have the equivallent relocations in the same order
+	def assemble_resolve(ary)
+		startlabel = new_label('section_start')
+
+		# create two bindings where all elements are the shortest/longest possible
+		minbinding = {}
+		minoff = 0
+		maxbinding = {}
+		maxoff = 0
+
+		ary.each { |elem|
+			case elem
+			when Array
+				if elem.all? { |ed| ed.kind_of? EncodedData and ed.reloc.empty? }
+					elem = [elem.sort_by { |ed| ed.length }.first]
+				end
+				elem.each { |e|
+					e.export.each { |label, off|
+						minbinding[label] = Expression[startlabel, :+, minoff + off]
+						maxbinding[label] = Expression[startlabel, :+, maxoff + off]
+					}
+				}
+				minoff += elem.map { |e| e.virtsize }.min
+				maxoff += elem.map { |e| e.virtsize }.max
+
+			when EncodedData
+				elem.export.each { |label, off|
+					minbinding[label] = Expression[startlabel, :+, minoff + off]
+					maxbinding[label] = Expression[startlabel, :+, maxoff + off]
+				}
+				minoff += elem.virtsize
+				maxoff += elem.virtsize
+
+			when Align
+				minoff += 0
+				maxoff += elem.val - 1
+
+			when Padding
+				# find the surrounding Offsets and compute the largest/shortest edata sizes to determine min/max length for the padding
+				prevoff = ary[0..ary.index(elem)].grep(Offset).last
+				nextoff = ary[ary.index(elem)..-1].grep(Offset).first
+				raise elem, 'need .offset after .pad' if not nextoff
+
+				# find all elements between the surrounding Offsets
+				previdx = prevoff ? ary.index(prevoff) + 1 : 0
+				surround = ary[previdx..ary.index(nextoff)-1]
+				surround.delete elem
+				if surround.find { |nelem| nelem.kind_of? Padding }
+					raise elem, 'need .offset beetween two .pad'
+				end
+				if surround.find { |nelem| nelem.kind_of? Align and ary.index(nelem) > ary.index(elem) }
+					raise elem, 'cannot .align after a .pad'	# XXX really ?
+				end
+
+				# lenmin/lenmax are the extrem length of the Padding
+				nxt = Expression[nextoff.val]
+				ext = nxt.externals
+				raise elem, "bad offset #{nxt}" if ext.length > 1 or (ext.length == 1 and not minbinding[ext.first])
+				nxt = Expression[nxt, :-, startlabel] if not nxt.bind(minbinding).reduce.kind_of? ::Integer
+				prv = Expression[prevoff ? prevoff.val : 0]
+				ext = prv.externals
+				raise elem, "bad offset #{prv}" if ext.length > 1 or (ext.length == 1 and not minbinding[ext.first])
+				prv = Expression[prv, :-, startlabel] if not prv.bind(minbinding).reduce.kind_of? ::Integer
+
+				lenmin = Expression[nxt.bind(minbinding), :-, prv.bind(maxbinding)].reduce
+				lenmax = Expression[nxt.bind(maxbinding), :-, prv.bind(minbinding)].reduce
+				raise elem, "bad labels: #{lenmin}" if not lenmin.kind_of? ::Integer or not lenmax.kind_of? ::Integer
+				surround.each { |nelem|
+					case nelem
+					when Array
+						lenmin -= nelem.map { |e| e.virtsize }.max
+						lenmax -= nelem.map { |e| e.virtsize }.min
+					when EncodedData
+						lenmin -= nelem.virtsize
+						lenmax -= nelem.virtsize
+					when Align
+						lenmin -= nelem.val - 1
+						lenmax -= 0
+					end
+				}
+				raise elem, "no room for .pad before '.offset #{nextoff.val}' at #{Backtrace.backtrace_str(nextoff.backtrace)}, need at least #{-lenmax} more bytes" if lenmax < 0
+				minoff += [lenmin, 0].max
+				maxoff += lenmax
+
+			when Offset
+				# nothing to do for now
+			else
+				raise "Internal error: bad object #{elem.inspect} in encode_resolve"
+			end
+		}
+
+		# checks an expression linearity
+		check_linear = lambda { |expr|
+			expr = expr.reduce if expr.kind_of? Expression
+			while expr.kind_of? Expression
+				case expr.op
+				when :*
+					if    expr.lexpr.kind_of? Numeric; expr = expr.rexpr
+					elsif expr.rexpr.kind_of? Numeric; expr = expr.lexpr
+					else  break
+					end
+				when :/, :>>, :<<
+					if    expr.rexpr.kind_of? Numeric; expr = expr.lexpr
+					else  break
+					end
+				when :+, :-
+					if    not expr.lexpr;              expr = expr.rexpr
+					elsif expr.lexpr.kind_of? Numeric; expr = expr.rexpr
+					elsif expr.rexpr.kind_of? Numeric; expr = expr.lexpr
+					else
+						break if not check_linear[expr.rexpr]
+						expr = expr.lexpr
+					end
+				else break
+				end
+			end
+
+			not expr.kind_of? Expression
+		}
+
+		# now we can resolve all relocations
+		# for linear expressions of internal variables (ie differences of labels from the ary):
+		#  - calc target numeric bounds, and reject relocs not accepting worst case value
+		#  - else reject all but largest place available
+		# then chose the shortest overall EData left
+		ary.map! { |elem|
+			case elem
+			when Array
+				# for each external, compute numeric target values using minbinding[external] and maxbinding[external]
+				# this gives us all extrem values for linear expressions
+				target_bounds = {}
+				rec_checkminmax = lambda { |idx, target, binding, extlist|
+					if extlist.empty?
+						(target_bounds[idx] ||= []) << target.bind(binding).reduce
+					else
+						rec_checkminmax[idx, target, binding.merge(extlist.last => minbinding[extlist.last]), extlist[0...-1]]
+						rec_checkminmax[idx, target, binding.merge(extlist.last => maxbinding[extlist.last]), extlist[0...-1]]
+					end
+				}
+				# biggest size disponible for this relocation (for non-linear/external)
+				wantsize = {}
+
+				elem.each { |e|
+					e.reloc.sort.each_with_index { |r_, i|
+						r = r_[1]
+						# has external ref
+						if not r.target.bind(minbinding).reduce.kind_of?(Numeric) or not check_linear[r.target]
+							# find the biggest relocation type for the current target
+							wantsize[i] = elem.map { |edata|
+								edata.reloc.sort[i][1].type
+							}.sort_by { |type| Expression::INT_SIZE[type] }.last	# XXX do not use rel.length
+						else
+							rec_checkminmax[i, r.target, {}, r.target.externals]
+						end
+					}
+				}
+
+				# reject candidates with reloc type too small
+				acceptable = elem.find_all { |edata|
+					r = edata.reloc.sort
+					(0...r.length).all? { |i|
+						if wantsize[i]
+							r[i][1].type == wantsize[i]
+						else
+							target_bounds[i].all? { |b| Expression.in_range?(b, r[i][1].type) }
+						end
+					}
+				}
+
+				raise EncodeError, "cannot find candidate in #{elem.inspect}, immediate too big #{wantsize.inspect} #{target_bounds.inspect}" if acceptable.empty?
+
+				# keep the shortest
+				acceptable.sort_by { |edata| edata.virtsize }.first
+			else
+				elem
+			end
+		}
+
+		# assemble all parts, resolve padding sizes, check offset directives
+		edata = EncodedData.new
+
+		# fills edata with repetitions of data until targetsize
+		fillwith = lambda { |targetsize, data|
+			if data
+				if data.reloc.empty? and not data.data.empty?	# avoid useless iterations
+					nr = (targetsize-edata.virtsize) / data.length - 1
+					if nr > 0
+						dat = data.data.ljust(data.virtsize, 0.chr)
+						edata << (dat * nr)
+					end
+				end
+				while edata.virtsize + data.virtsize <= targetsize
+					edata << data
+				end
+				if edata.virtsize < targetsize
+					edata << data[0, targetsize - edata.virtsize]
+				end
+			else
+				edata.virtsize = targetsize
+			end
+		}
+
+		ary.each { |elem|
+			case elem
+			when EncodedData
+				edata << elem
+			when Align
+				fillwith[EncodedData.align_size(edata.virtsize, elem.val), elem.fillwith]
+			when Offset
+				raise EncodeError, "could not enforce .offset #{elem.val} #{elem.backtrace}: offset now #{edata.virtsize}" if edata.virtsize != Expression[elem.val].bind(edata.binding(0)).reduce
+			when Padding
+				nextoff = ary[ary.index(elem)..-1].grep(Offset).first
+				targetsize = Expression[nextoff.val].bind(edata.binding(0)).reduce
+				ary[ary.index(elem)+1..ary.index(nextoff)-1].each { |nelem| targetsize -= nelem.virtsize }
+				raise EncodeError, "no room for .pad #{elem.backtrace_str} before .offset #{nextoff.val}, would be #{targetsize-edata.length} bytes long" if targetsize < edata.length
+				fillwith[targetsize, elem.fillwith]
+			else raise "Internal error: #{elem.inspect}"
+			end
+		}
+
+		edata
+	end
+end
+
+class Expression
+	def encode(type, endianness, backtrace=nil)
+		case val = reduce
+		when Integer; EncodedData.new Expression.encode_imm(val, type, endianness, backtrace)
+		else          EncodedData.new([0].pack('C')*(INT_SIZE[type]/8), :reloc => {0 => Relocation.new(self, type, endianness, backtrace)})
+		end
+	end
+
+	class << self
+	def encode_imm(val, type, endianness, backtrace=nil)
+		type = INT_SIZE.keys.find { |k| k.to_s[0] == ?a and INT_SIZE[k] == 8*type } if type.kind_of? ::Integer
+		endianness = endianness.endianness if not endianness.kind_of? ::Symbol
+		raise "unsupported endianness #{endianness.inspect}" unless [:big, :little].include? endianness
+		raise(EncodeError, "immediate overflow #{type.inspect} #{Expression[val]} #{(Backtrace::backtrace_str(backtrace) if backtrace)}") if not in_range?(val, type)
+		s = (0...INT_SIZE[type]/8).map { |i| (val >> (8*i)) & 0xff }.pack('C*')
+		endianness != :little ? s.reverse : s
+	end
+	alias encode_immediate encode_imm
+	end
+end
+
+class Data
+	def encode(endianness)
+		edata = case @data
+		when :uninitialized
+			EncodedData.new('', :virtsize => Expression::INT_SIZE[INT_TYPE[@type]]/8)
+		when String
+			# db 'foo' => 'foo' # XXX could be optimised, but should not be significant
+			# dw 'foo' => "f\0o\0o\0" / "\0f\0o\0o"
+			@data.unpack('C*').inject(EncodedData.new) { |ed, chr| ed << Expression.encode_imm(chr, INT_TYPE[@type], endianness, @backtrace) }
+		when Expression
+			@data.encode INT_TYPE[@type], endianness, @backtrace
+		when Array
+			@data.inject(EncodedData.new) { |ed, d| ed << d.encode(endianness) }
+		end
+
+		# n times
+		(0...@count).inject(EncodedData.new) { |ed, cnt| ed << edata }
+	end
+end
+
+class CPU
+	# returns an EncodedData or an ary of them
+	# uses +#parse_arg_valid?+ to find the opcode whose signature matches with the instruction
+	# uses +encode_instr_op+ (arch-specific)
+	def encode_instruction(program, i)
+		errmsg = ''
+		oplist = opcode_list_byname[i.opname].to_a.find_all { |o|
+			o.args.length == i.args.length and
+			o.args.zip(i.args).all? { |f, a| parse_arg_valid?(o, f, a) }
+		}.map { |op|
+			begin
+				encode_instr_op(program, i, op)
+			rescue EncodeError
+				errmsg = " (#{$!.message})"
+				nil
+			end
+		}.compact.flatten
+		raise EncodeError, "no matching opcode found for #{i}#{errmsg}" if oplist.empty?
+		oplist.each { |ed| ed.reloc.each_value { |v| v.backtrace = i.backtrace } }
+		oplist
+	end
+end
+end

data/lib/metasm/exe_format/a_out.rb

@@ -0,0 +1,194 @@
+#    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 AOut < ExeFormat
+	MAGIC = { 0407 => 'OMAGIC', 0410 => 'NMAGIC', 0413 => 'ZMAGIC',
+		0314 => 'QMAGIC', 0421 => 'CMAGIC'
+	}
+	MACHINE_TYPE = { 0 => 'OLDSUN2', 1 => '68010', 2 => '68020',
+		3 => 'SPARC', 100 => 'PC386', 134 => 'I386', 135 => 'M68K',
+		136 => 'M68K4K', 137 => 'NS32532', 138 => 'SPARC',
+		139 => 'PMAX', 140 => 'VAX', 141 => 'ALPHA', 142 => 'MIPS',
+		143 => 'ARM6', 151 => 'MIPS1', 152 => 'MIPS2', 300 => 'HP300',
+		0x20B => 'HPUX800', 0x20C => 'HPUX'
+	}
+	FLAGS = { 0x10 => 'PIC', 0x20 => 'DYNAMIC' }
+	SYMBOL_TYPE = { 0 => 'UNDF', 1 => 'ABS', 2 => 'TEXT',
+		3 => 'DATA', 4 => 'BSS', 5 => 'INDR', 6 => 'SIZE',
+		9 => 'COMM', 10=> 'SETA', 11=> 'SETT', 12=> 'SETD',
+		13=> 'SETB', 14=> 'SETV', 15=> 'FN'
+	}
+
+	attr_accessor :endianness, :header, :text, :data, :symbols, :textrel, :datarel
+
+	class Header < SerialStruct
+		bitfield :word, 0 => :magic, 16 => :machtype, 24 => :flags
+		fld_enum(:magic, MAGIC)
+		fld_enum(:machtype, MACHINE_TYPE)
+		fld_bits(:flags, FLAGS)
+		words :text, :data, :bss, :syms, :entry, :trsz, :drsz
+
+		def decode(aout)
+			super(aout)
+
+			case @magic
+			when 'OMAGIC', 'NMAGIC', 'ZMAGIC', 'QMAGIC'
+			else raise InvalidExeFormat, "Bad A.OUT signature #@magic"
+			end
+		end
+
+		def set_default_values(aout)
+			@magic ||= 'QMAGIC'
+			@machtype ||= 'PC386'
+			@flags ||= []
+			@text ||= aout.text.length + (@magic == 'QMAGIC' ? 32 : 0) if aout.text
+			@data ||= aout.data.length if aout.data
+
+			super(aout)
+		end
+	end
+
+	class Relocation < SerialStruct
+		word :address
+		bitfield :word, 0 => :symbolnum, 24 => :pcrel, 25 => :length,
+ 			27 => :extern, 28 => :baserel, 29 => :jmptable, 30 => :relative, 31 => :rtcopy
+		fld_enum :length, 0 => 1, 1 => 2, 2 => 4, 3 => 8
+		fld_default :length, 4
+	end
+
+	class Symbol < SerialStruct
+		word :name_p
+		bitfield :byte, 0 => :extern, 1 => :type, 5 => :stab
+		byte :other
+		half :desc
+ 		word :value
+		attr_accessor :name
+
+		def decode(aout, strings=nil)
+			super(aout)
+			@name = strings[@name_p...(strings.index(?\0, @name_p))] if strings
+		end
+
+		def set_default_values(aout, strings=nil)
+			if strings and name and @name != ''
+				if not @name_p or strings[@name_p, @name.length] != @name
+					@name_p = strings.length
+					strings << @name << 0
+				end
+			end
+			super(aout, strings)
+		end
+	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
+	def encode_byte(w) Expression[w].encode(:u8 , @endianness) end
+	def encode_half(w) Expression[w].encode(:u16, @endianness) end
+	def encode_word(w) Expression[w].encode(:u32, @endianness) end
+
+	def initialize(cpu = nil)
+		@endianness = cpu ? cpu.endianness : :little
+		@header = Header.new
+		@text = EncodedData.new
+		@data = EncodedData.new
+		super(cpu)
+	end
+
+	def decode_header
+		@encoded.ptr = 0
+		@header.decode(self)
+	end
+
+	def decode
+		decode_header
+
+		tlen = @header.text
+		case @header.magic
+		when 'ZMAGIC'; @encoded.ptr = 1024
+		when 'QMAGIC'; tlen -= 32	# header is included in .text
+		end
+		@text = EncodedData.new << @encoded.read(tlen)
+
+		@data = EncodedData.new << @encoded.read(@header.data)
+
+		textrel = @encoded.read @header.trsz
+		datarel = @encoded.read @header.drsz
+		syms    = @encoded.read @header.syms
+		strings = @encoded.read
+		# TODO
+	end
+
+	def encode
+		# non mmapable on linux anyway
+		# could support OMAGIC..
+		raise EncodeError, 'cannot encode non-QMAGIC a.out' if @header.magic and @header.magic != 'QMAGIC'
+
+		# data must be 4096-aligned
+		# 32 bytes of header included in .text
+		@text.virtsize = (@text.virtsize + 32 + 4096 - 1) / 4096 * 4096 - 32
+		if @data.rawsize % 4096 != 0
+			@data[(@data.rawsize + 4096 - 1) / 4096 * 4096 - 1] = 0
+		end
+
+		@header.text = @text.length+32
+		@header.data = @data.rawsize
+		@header.bss = @data.virtsize - @data.rawsize
+
+		@encoded = EncodedData.new
+		@encoded << @header.encode(self)
+		binding = @text.binding(4096+32).merge @data.binding(4096 + @header.text)
+		@encoded << @text << @data
+		@encoded.fixup! binding
+		@encoded.data
+	end
+
+	def parse_init
+		@textsrc ||= []
+		@datasrc ||= []
+		@cursource ||= @textsrc
+		super()
+	end
+
+	def parse_parser_instruction(instr)
+		case instr.raw.downcase
+		when '.text'; @cursource = @textsrc
+		when '.data'; @cursource = @datasrc
+		when '.entrypoint'
+			# ".entrypoint <somelabel/expression>" or ".entrypoint" (here)
+			@lexer.skip_space
+			if tok = @lexer.nexttok and tok.type == :string
+				raise instr if not entrypoint = Expression.parse(@lexer)
+			else
+				entrypoint = new_label('entrypoint')
+				@cursource << Label.new(entrypoint, instr.backtrace.dup)
+			end
+			@header.entry = entrypoint
+		else super(instr)
+		end
+	end
+
+	def assemble(*a)
+		parse(*a) if not a.empty?
+		@text << assemble_sequence(@textsrc, @cpu)
+		@textsrc.clear
+		@data << assemble_sequence(@datasrc, @cpu)
+		@datasrc.clear
+		self
+	end
+
+	def each_section
+		tva = 0
+		tva = 4096+32 if @header.magic == 'QMAGIC'
+		yield @text, tva
+		yield @data, tva + @text.virtsize
+	end
+end
+end