evoasm 0.0.2.pre7 → 0.1.0.pre2

data/lib/evoasm.rb

@@ -1,22 +1,39 @@
 require 'evoasm/version'
-require 'evoasm/core_ext'
 
 module Evoasm
-  def self.root
+  def self.root_dir
     File.expand_path File.join(__dir__, '..')
   end
 
-  def self.data
-    File.join root, 'data'
+  def self.data_dir
+    File.join root_dir, 'data'
+  end
+
+  def self.test_dir
+    File.join root_dir, 'test'
+  end
+
+  def self.data_dir
+    File.join root_dir, 'data'
+  end
+
+  def self.ext_dir
+    File.join root_dir, 'ext'
+  end
+
+  def self.log_level=(log_level)
+    Libevoasm.set_log_level log_level
   end
-end
 
-begin
-  require 'evoasm_ext'
-rescue LoadError => e
-  p e
+  def self.architecture
+    Libevoasm.get_current_arch
+  end
 end
 
-require 'evoasm/search'
-require 'evoasm/program'
+require 'evoasm/libevoasm'
 require 'evoasm/error'
+
+Evoasm::Libevoasm.init(0, FFI::Pointer::NULL, FFI::Pointer::NULL)
+
+require 'evoasm/population'
+require 'evoasm/buffer'

data/lib/evoasm/buffer.rb

@@ -0,0 +1,105 @@
+require 'evoasm/exception_error'
+
+module Evoasm
+  # Represents an executable area of memory
+  class Buffer < FFI::AutoPointer
+
+    # @!visibility private
+    def self.release(ptr)
+      Libevoasm.buf_destroy(ptr)
+      Libevoasm.buf_free(ptr)
+    end
+
+    # @param capacity [Integer] the buffer's capacity in bytes
+    # @param type [:mmap, :malloc] the buffer type, only buffers created with +:mmap+ are executable
+    def initialize(capacity, type = :mmap)
+      ptr = Libevoasm.buf_alloc
+      unless Libevoasm.buf_init ptr, type, capacity
+        Libevoasm.buf_free ptr
+        raise Error.last
+      end
+      super(ptr)
+    end
+
+    # @!attribute [r] capacity
+    # @return [Integer] the buffer's capacity
+    def capacity
+      Libevoasm.buf_get_capa self
+    end
+
+    # @!attribute [r] position
+    # @return [Integer] the buffer cursor's current position
+    def position
+      Libevoasm.buf_get_pos self
+    end
+
+    # Resets the buffers position to zero
+    # @return [void]
+    def reset
+      Libevoasm.buf_reset self
+    end
+
+    # @!attribute [r] type
+    # @return [:mmap, :malloc] the buffer's current position
+    def type
+      Libevoasm.buf_get_type self
+    end
+
+    # Gives the buffer's content as string
+    # @return [String]
+    def to_s
+      ptr = Libevoasm.buf_get_data self
+      ptr.read_string capacity
+    end
+
+    # @!visibility private
+    def __log__(log_level)
+      Libevoasm.buf_log self, log_level
+    end
+
+    # Writes data into the buffer and advances the buffer position
+    # @param data [String] the data to write into the buffer
+    def write(data)
+      data_ptr = FFI::MemoryPointer.new :uint8, data.size
+      data_ptr.write_string data
+
+      if Libevoasm.buf_write(self, data_ptr, data.size) != 0
+        raise Error.last
+      end
+    end
+
+    # Executes the buffer's content.
+    # @raise [ExceptionError] if a hardware exception occurred
+    def execute!
+      begin
+
+        unless Libevoasm.buf_protect self, :rx
+          raise Error.last
+        end
+
+        current_arch = Libevoasm.get_current_arch
+        return_value = nil
+        exception_enum = Libevoasm.enum_type(:"#{current_arch}_exception")
+        # catch everything
+        exception_mask = exception_enum.flags(exception_enum.symbols, shift: true)
+
+        #FIXME: should be intptr_t, but FFI sucks
+        return_value_ptr = FFI::MemoryPointer.new :size_t, 1
+
+        success = Libevoasm.buf_safe_exec(self, exception_mask, return_value_ptr)
+        return_value = return_value_ptr.read_size_t
+
+
+        if success
+          return return_value
+        else
+          raise ExceptionError.new(current_arch, exception_enum[return_value])
+        end
+      ensure
+        unless Libevoasm.buf_protect self, :rw
+          raise Error.last
+        end
+      end
+    end
+  end
+end

data/lib/evoasm/capstone.rb

@@ -0,0 +1,100 @@
+require 'ffi'
+
+module Evoasm
+
+  # @!visibility private
+  module Capstone
+    class Error < StandardError; end
+
+    module Libcapstone
+      extend FFI::Library
+
+      ffi_lib ['capstone', 'libcapstone.so.3']
+
+      class Insn < FFI::Struct
+        layout :id, :uint,
+               :address, :uint64,
+               :size, :uint16,
+               :bytes, [:uchar, 16],
+               :mnemonic, [:char, 32],
+               :op_str, [:char, 160],
+               :detail, :pointer
+      end
+
+      enum :cs_mode, [
+        :mode_64, 1 << 3
+      ]
+
+      enum :cs_arch, [
+        :arch_x86, 3
+      ]
+
+      enum :cs_err, [
+        	:err_ok, 0,
+	        :err_mem,
+          :err_arch,
+	        :err_handle,
+        	:err_csh,
+        	:err_mode,
+        	:err_option,
+        	:err_detail,
+        	:err_memsetup,
+        	:err_version,
+        	:err_diet,
+        	:err_skipdata,
+        	:err_x86_att,
+        	:err_x86_intel,
+      ]
+
+      typedef :pointer, :cs_insn
+      typedef :size_t, :csh
+      typedef :pointer, :csh_ptr
+
+      attach_function :cs_close, [:csh_ptr], :cs_err
+      attach_function :cs_open, [:cs_arch, :cs_mode, :csh_ptr], :cs_err
+      attach_function :cs_strerror, [:cs_err], :string
+      attach_function :cs_free, [:pointer, :size_t], :void
+      attach_function :cs_disasm, [:csh, :pointer, :size_t, :uint64, :size_t, :pointer], :size_t
+      attach_function :cs_errno, [:csh], :cs_err
+    end
+
+    def self.disassemble_x64(asm, addr = nil)
+      result = []
+      handle_ptr = FFI::MemoryPointer.new(:size_t, 1)
+
+      err = Libcapstone.cs_open :arch_x86, :mode_64, handle_ptr
+      if err != :err_ok
+        raise Error, cs_strerror(err);
+      end
+
+      handle = handle_ptr.read_size_t
+
+      insns_ptr = FFI::MemoryPointer.new :pointer
+      count = Libcapstone.cs_disasm(handle, asm, asm.bytesize, addr ? addr : 0, 0, insns_ptr)
+      insns = insns_ptr.read_pointer
+      if count > 0
+        count.times do |c|
+          insn_ptr = insns + c * Libcapstone::Insn.size
+          insn = Libcapstone::Insn.new insn_ptr
+          line = []
+          line << insn[:address] if addr
+          line << insn[:mnemonic].to_s << insn[:op_str].to_s
+          result << line
+        end
+        err = :err_ok
+      else
+        err = Libcapstone.cs_errno handle
+      end
+
+      Libcapstone.cs_free insns, count
+      Libcapstone.cs_close handle_ptr
+
+      if err != :err_ok
+        raise Error, Libcapstone.cs_strerror(err);
+      end
+
+      result
+    end
+  end
+
+end

data/lib/evoasm/domain.rb

@@ -0,0 +1,116 @@
+require 'evoasm/ffi_ext'
+require 'evoasm/prng'
+
+module Evoasm
+  # @!visibility private
+  class Domain < FFI::AutoPointer
+    class << self
+      def release(ptr)
+        Libevoasm.domain_free ptr
+      end
+
+      def wrap(ptr)
+        type = Libevoasm.domain_get_type ptr
+        case type
+        when :enum
+          EnumerationDomain.new_from_pointer ptr
+        when :range
+          RangeDomain.new_from_pointer ptr
+        when :int8, :int16, :int32, :int64
+          TypeDomain.new_from_pointer ptr
+        else
+          raise "invalid domain type #{type}"
+        end
+      end
+
+      def for(value)
+        case value
+        when self
+          value
+        when Range
+          RangeDomain.new value.min, value.max
+        when Array
+          EnumerationDomain.new *value
+        else
+          raise ArgumentError, "cannot convert into domain"
+        end
+      end
+
+      protected
+
+      alias new_from_pointer new
+
+      def new(type, var_args)
+        ptr = Libevoasm.domain_alloc
+        success = Libevoasm.domain_init ptr, type, *var_args
+
+        if success
+          super(ptr)
+        else
+          Libevoasm.domain_free ptr
+          raise Error.last
+        end
+      end
+    end
+
+    def rand(prng = PRNG.default)
+      Libevoasm.domain_rand self, prng
+    end
+
+    def bounds
+      return nil if is_a?(EnumerationDomain)
+
+      min = FFI::MemoryPointer.new :int64
+      max = FFI::MemoryPointer.new :int64
+
+      Libevoasm.domain_get_bounds self, min, max
+
+      [min.read_int64, max.read_int64]
+    end
+
+    def min
+      bounds[0]
+    end
+
+    def max
+      bounds[1]
+    end
+  end
+
+  # @!visibility private
+  class EnumerationDomain < Domain
+    def self.new(*values)
+      values = values.flatten
+      var_args = [:uint, values.size, *values.flat_map { |v| [:int64, v]}]
+      super(:enum, var_args)
+    end
+
+    def length
+      Libevoasm.enum_domain_get_len self
+    end
+
+    def values
+      Array.new(length) do |index|
+        Libevoasm.enum_domain_get_val self, index
+      end
+    end
+  end
+
+  # @!visibility private
+  class RangeDomain < Domain
+    def self.new(min, max)
+      super(:range, [:int64, min, :int64, max])
+    end
+  end
+
+  # @!visibility private
+  class TypeDomain < Domain
+    def self.new(type)
+      super(type, [])
+    end
+
+    def type
+      Libevoasm.domain_get_type self
+    end
+  end
+end

data/lib/evoasm/error.rb

@@ -1,20 +1,41 @@
 module Evoasm
-  class Error
-    def message
-      msg = __message
-
-      case code
-      when :not_encodable
-        "#{msg} #{parameter}"
-      when :missing_param
-        "#{msg} (#{parameter})"
-      when :missing_feature
-        "missing features #{features.join ', '}"
-      when :invalid_access
-        "#{msg} (#{instruction}/#{register})"
-      else
-        msg || code
-      end
+  # Represents an low-level error (originating from the backend library).
+  class Error < StandardError
+
+    # @return [Integer] the line number at which this error occurred
+    attr_reader :line
+
+    # @return [Symbol] the error type
+    attr_reader :type
+
+    # @return [Symbol] the error code
+    attr_reader :code
+
+    # @return [String] the filename of the source file this error occurred in
+    attr_reader :filename
+
+    # @!visibility private
+    def self.last
+      self.new(Libevoasm.get_last_error)
+    end
+
+    # @!visibility private
+    def initialize(ptr)
+      message = Libevoasm.error_get_msg ptr
+
+      @type = Libevoasm.error_get_type ptr
+      @code = Libevoasm.error_get_code ptr
+      @filename = Libevoasm.error_get_filename ptr
+      @line = Libevoasm.error_get_line ptr
+
+      super(message)
+    end
+
+    # @!visibility private
+    def backtrace
+      backtrace = super
+      backtrace.unshift "#{@filename}:#{@line}" if backtrace
+      backtrace
     end
   end
 end

data/lib/evoasm/exception_error.rb

@@ -0,0 +1,19 @@
+module Evoasm
+  # Represents a hardware exception (e.g. division by zero).
+  class ExceptionError < StandardError
+
+    # @return [Symbol] the exception name
+    attr_reader :exception_name
+
+    # @return [Symbol] the architecture
+    attr_reader :architecture
+
+    # @!visibility private
+    def initialize(architecture, exception_name)
+      @architecture = architecture
+      @exception_name = exception_name
+
+      super("#{exception_name} was signalled")
+    end
+  end
+end