evoasm 0.0.2.pre7 → 0.1.0.pre2

data/lib/evoasm/x64/cpu_state.rb

@@ -0,0 +1,95 @@
+require 'evoasm/x64'
+
+module Evoasm
+  module X64
+    # Represents the CPU state (i.e. a snapshot of all registers)
+    # at a specific moment in time.
+    class CPUState < FFI::AutoPointer
+
+      # @!visibility private
+      def self.release(ptr)
+        Libevoasm.x64_cpu_state_destroy(ptr)
+        Libevoasm.x64_cpu_state_free(ptr)
+      end
+
+      # @param flags [Array<Symbol>]
+      def initialize(flags = [:rflags])
+        ptr = Libevoasm.x64_cpu_state_alloc
+        Libevoasm.x64_cpu_state_init ptr, Libevoasm.enum_type(:x64_cpu_state_flags).flags(flags, shift: false)
+        super(ptr)
+      end
+
+      # Sets the value of a register
+      # @param register [Symbol] register to set
+      # @param data [Array<Integer>, Integer] value as a single 64-bit integer or an array of multiple
+      #   64-bit integers (e.g. for vector registers)
+      # @return [void]
+      def []=(register, data)
+        data = Array(data)
+        ptr = FFI::MemoryPointer.new :uint64, data.size
+        ptr.write_array_of_uint64 data
+        Libevoasm.x64_cpu_state_set self, register, ptr, data.size
+      end
+
+      # Obtain the value of a register
+      # @param register [Symbol] the register
+      # @param word [Symbol] an optional word to mask the value (e.g. to obtain a subregister value)
+      # @return [Array<Integer>] the register's value as an array of 64-bit integers
+      def [](register, word = :none)
+        data_ptr = FFI::MemoryPointer.new :uint64, 16
+        data_len = Libevoasm.x64_cpu_state_get self, register, word, data_ptr, 16
+        data_ptr.read_array_of_uint64 data_len
+      end
+
+      # Clone this CPU state object
+      # @return [CPUState] the cloned object
+      def clone
+        cloned_cpu_state = self.class.new
+        Libevoasm.x64_cpu_state_clone self, cloned_cpu_state
+
+        cloned_cpu_state
+      end
+
+      # @!visibility private
+      def xor(other)
+        xored = self.class.new
+        Libevoasm.x64_cpu_state_xor self, other, xored
+        xored
+      end
+
+      # Converts this object into a hash
+      # @return [Hash] the hash
+      def to_h
+        X64.registers.each_with_object({}) do |register, hash|
+          hash[register] = self[register]
+        end
+      end
+
+      def get_rflags_flag(flag)
+        Libevoasm.x64_cpu_state_get_rflags_flag self, flag
+      end
+
+      # Emits machine code to store (save) the current CPU state
+      # into this object
+      # @param buffer [Buffer] the buffer to emit to
+      # @return [void]
+      # @raise [Error] if an error occurres
+      def emit_store(buffer)
+        unless Libevoasm.x64_cpu_state_emit_store self, buffer
+          raise Error.last
+        end
+      end
+
+      # Emits machine code to load (set) the current CPU state to
+      # the state of this object
+      # @param buffer [Buffer] the buffer to emit to
+      # @return [void]
+      # @raise [Error] if an error occurres
+      def emit_load(buffer)
+        unless Libevoasm.x64_cpu_state_emit_load self, buffer
+          raise Error.last
+        end
+      end
+    end
+  end
+end

data/lib/evoasm/x64/instruction.rb

@@ -0,0 +1,109 @@
+require 'evoasm/parameter'
+
+module Evoasm
+  module X64
+    # Represents an x86-64 instruction
+    class Instruction < FFI::Pointer
+      class Parameter < Evoasm::Parameter
+        # Returns the parameter's name
+        # @return [Symbol] the parameter name
+        def name
+          Libevoasm.enum_type(:x64_param_id).find id
+        end
+      end
+
+      # @return [Symbol] the instruction's name
+      attr_reader :name
+
+      # @!visibility private
+      def initialize(ptr, name)
+        super(ptr)
+        @name = name
+      end
+
+      # Gives a list of instruction mnemonics
+      # @return [Array<String>] mnemonics
+      def mnemonics
+        Libevoasm.x64_inst_get_mnem(self).split('/')
+      end
+
+      # Gives the preferred instruction mnemonic
+      # @return [String] the mnemonics
+      # @see #mnemonics
+      def mnemonic
+        mnemonics.first
+      end
+
+      # Gives the operand at the specified index
+      # @return [Operand] the operand
+      def operand(index)
+        Operand.new Libevoasm.x64_inst_get_operand(self, index), self
+      end
+
+      # Gives the instruction's operands
+      # @return [Array<Operand>] the operands
+      def operands
+        n_operands = Libevoasm.x64_inst_get_n_operands self
+        Array.new(n_operands) do |index|
+          operand index
+        end
+      end
+
+      # Gives this instruction's parameters
+      # @return [Array<Instruction::Parameter>] the parameters
+      def parameters
+        n_params = Libevoasm.x64_inst_get_n_params self
+        Array.new(n_params) do |param_index|
+          Parameter.new Libevoasm.x64_inst_get_param(self, param_index)
+        end
+      end
+
+      # Returns whether this instruction is encodable with the basic encoder
+      # @return [Bool]
+      def basic?
+        Libevoasm.x64_inst_is_basic(self)
+      end
+
+      # Encodes the instruciton with the given parameters
+      # @param parameters [X64::Parameters] parameters
+      # @param buffer [Buffer] the buffer to emit to
+      # @param basic [Bool] whether the basic encoder should be used
+      # @return [void]
+      def encode(parameters, buffer = nil, basic: false)
+        if basic && !basic?
+          raise ArgumentError, 'instruction does not support basic mode'
+        end
+
+        buf_ref = Libevoasm.buf_ref_alloc
+
+        if buffer
+          Libevoasm.buf_to_buf_ref buffer, buf_ref
+        else
+          data = FFI::MemoryPointer.new :uint8, 32
+          len_ptr = FFI::MemoryPointer.new :size_t, 1
+          Libevoasm.buf_ref_init buf_ref, data, len_ptr
+        end
+
+        parameters = Parameters.for(parameters, basic: basic)
+
+        success =
+          if basic
+            Libevoasm.x64_inst_enc_basic self, parameters, buf_ref
+          else
+            Libevoasm.x64_inst_enc self, parameters, buf_ref
+          end
+
+        Libevoasm.buf_ref_free buf_ref
+
+        if success
+          unless buffer
+            len = len_ptr.read_size_t
+            data.read_string len
+          end
+        else
+          raise Error.last
+        end
+      end
+    end
+  end
+end

data/lib/evoasm/x64/operand.rb

@@ -0,0 +1,156 @@
+module Evoasm
+  module X64
+    # Represents a formal instruction operand
+    class Operand < FFI::Pointer
+
+      # @return [X64::Instruction] the instruction this operand belongs to
+      attr_reader :instruction
+
+      # @!visibility private
+      def initialize(ptr, instruction)
+        super(ptr)
+        @instruction = instruction
+      end
+
+      # Gives the parameter affecting this operand
+      # @return [X64::Parameter] the parameter
+      def parameter
+        @instruction.parameters[Libevoasm.x64_operand_get_param_idx self]
+      end
+
+      # Returns whether this operand is read
+      def read?
+        Libevoasm.x64_operand_is_read self
+      end
+
+      # Returns whether this operand is written
+      def written?
+        Libevoasm.x64_operand_is_written self
+      end
+
+      # Returns whether this operand is possibliy written (e.g. in a conditional move instruction)
+      def maybe_written?
+        Libevoasm.x64_operand_is_maybe_written self
+      end
+
+      # Returns whether this operand is part of the instruction mnemonic
+      def mnemonic?
+        Libevoasm.x64_operand_is_mnem self
+      end
+
+      # Returns whether this operand is implicit
+      def implicit?
+        Libevoasm.x64_operand_is_implicit self
+      end
+
+      # Returns whether this operand is explicit
+      def explicit?
+        !implicit?
+      end
+
+      # Returns the operand type
+      # @return [:rm, :imm, :reg] the operand type
+      def type
+        Libevoasm.x64_operand_get_type self
+      end
+
+      # Returns the operand's register (e.g. if implicit) if available
+      # @return [Symbol, nil] the operand's register or nil if there is none
+      def register
+        if type == :rm || type == :reg
+          reg_id = Libevoasm.x64_operand_get_reg_id self
+          reg_id == :none ? nil : reg_id
+        else
+          nil
+        end
+      end
+
+      INVALID_IMMEDIATE = -1
+
+      # Returns the operand's immediate (e.g. if implicit) if available
+      # @return [Integer, nil] the operand's immediate or nil if there is none
+      def immediate
+        if type == :imm
+          imm = Libevoasm.x64_operand_get_imm self
+          imm == INVALID_IMMEDIATE ? nil : imm
+        else
+          nil
+        end
+      end
+
+      # Returns the operand's register type (e.g. if implicit) if available
+      # @return [Symbol, nil] the operand's register type or nil if there is none
+      def register_type
+        reg_type = Libevoasm.x64_operand_get_reg_type self
+        reg_type == :none ? nil : reg_type
+      end
+
+      # Gives the operand's size
+      # @return [Integer] the operand size in bits
+      def size
+        convert_size Libevoasm.x64_operand_get_size(self)
+      end
+
+      # Gives the operand's word
+      # @return [Symbol] the operand word
+      def word
+        Libevoasm.x64_operand_get_word(self)
+      end
+
+      # Returns the operand's register size
+      # @return [Integer, nil] the operand's registert size or nil if this operand does not hold a register
+      def register_size
+        if type == :rm || type == :reg
+          convert_size Libevoasm.x64_operand_get_reg_size(self)
+        else
+          nil
+        end
+      end
+
+      # Returns the operand's index register size (e.g. in VSIB instructions)
+      # @return [Integer, nil] the operand's index registert size or nil if this operand does not hold a index register
+      def index_register_size
+        if type == :vsib
+          convert_size Libevoasm.x64_operand_get_index_reg_size(self)
+        else
+          nil
+        end
+      end
+
+      # Returns the operand's memory size (e.g. in R/M instructions)
+      # @return [Integer, nil] the operand's memory size or nil if this operand is not a memory operand
+      def memory_size
+        if type == :rm || type == :mem || type == :vsib
+          convert_size Libevoasm.x64_operand_get_mem_size(self)
+        else
+          nil
+        end
+      end
+
+      private
+
+      def convert_size(size)
+        case size
+        when :'1' then
+          1
+        when :'8' then
+          8
+        when :'16' then
+          16
+        when :'32' then
+          32
+        when :'64' then
+          64
+        when :'128' then
+          128
+        when :'256' then
+          256
+        when :'512' then
+          512
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/evoasm/x64/parameters.rb

@@ -0,0 +1,211 @@
+module Evoasm
+  module X64
+    # Represents x86-64 instruction parameters.
+    class Parameters < FFI::AutoPointer
+
+      # @!visibility private
+      def self.release(ptr)
+        if ptr.basic?
+          Libevoasm.x64_basic_params_free ptr
+        else
+          Libevoasm.x64_params_free ptr
+        end
+      end
+
+      # @!visibility private
+      def self.for(parameters, basic: false)
+        case parameters
+        when self
+          if basic && !parameters.basic?
+            raise ArgumentError, 'cannot convert non-basic parameters '\
+                                 'to basic parameters'
+          end
+          parameters
+        when Hash
+          new parameters, basic: basic
+        else
+          raise ArgumentError, "cannot convert #{parameters.class} into parameter"
+        end
+      end
+
+      def inspect
+        fields = @param_id_enum_type.symbols[0..-2].map { |s| "#{s}:#{self[s]}" }.join(' ')
+        "#<#{self.class.inspect} #{fields}>"
+      end
+
+      # @param hash [Hash] a
+      # @param basic [Bool] whether to use the basic encoder
+      def initialize(hash = {}, basic: false)
+        if basic
+          ptr = Libevoasm.x64_basic_params_alloc
+          Libevoasm.x64_basic_params_init ptr
+        else
+          ptr = Libevoasm.x64_params_alloc
+          Libevoasm.x64_params_init ptr
+        end
+
+        @param_id_enum_type =
+          if basic
+            Libevoasm.enum_type(:x64_basic_param_id)
+          else
+            Libevoasm.enum_type(:x64_param_id)
+          end
+
+        @basic = basic
+        @disp_size_enum_type = Libevoasm.enum_type :x64_disp_size
+        @addr_size_enum_type = Libevoasm.enum_type :x64_addr_size
+        @scale_enum_type = Libevoasm.enum_type :x64_scale
+        @reg_id_enum_type = Libevoasm.enum_type :x64_reg_id
+
+        @type_map_enum_types = {
+          scale: @scale_enum_type,
+          addr_size: @addr_size_enum_type,
+          reg: @reg_id_enum_type
+        }
+
+        @type_map = {
+          scale: {
+            1 => :scale1,
+            2 => :scale2,
+            4 => :scale4,
+            8 => :scale8
+          },
+
+          addr_size: {
+            32 => :addr_size32,
+            64 => :addr_size64,
+          },
+
+          bool: {
+            true => 1,
+            false => 0
+          },
+
+          uint1: proc { |v| check_uint_range v, 1 },
+          int3: proc { |v| check_int_range v, 3 },
+          int4: proc { |v| check_int_range v, 4 },
+          int8: proc { |v| check_int_range v, 8 },
+          int32: proc { |v| check_int_range v, 32 },
+          int64: proc { |v| check_int_range v, 64 },
+          reg: proc { |v| @reg_id_enum_type[v] }
+        }
+
+        @inv_type_map = @type_map.map do |k, v|
+          if v.is_a? Hash
+            [k, v.invert]
+          else
+            [k, v]
+          end
+        end.to_h
+
+        @inv_type_map[:reg] = proc { |v| v }
+
+        super(ptr)
+
+        hash.each do |k, v|
+          self[k] = v
+        end
+      end
+
+      # Returns whether this parameters are for basic encodning
+      # @return [Bool]
+      def basic?
+        @basic
+      end
+
+      # @param parameter_name [Symbol] the parameter's name
+      # @return [Symbol, Integer] the parameter value
+      def [](parameter_name)
+        ffi_value =
+          if basic?
+            Libevoasm.x64_basic_params_get self, parameter_name_to_id(parameter_name)
+          else
+            Libevoasm.x64_params_get self, parameter_name_to_id(parameter_name)
+          end
+
+        ffi_value_to_value parameter_name, ffi_value
+      end
+
+      # Checks the existence of a parameter
+      # @param parameter_name [Symbol] the parameter name
+      # @return [Bool] whether the parameter exists or nor
+      def parameter?(parameter_name)
+        !@param_id_enum_type[parameter_name].nil?
+      end
+
+      # Set a parameter
+      # @param parameter_name [Symbol] the parameter's name
+      # @param value [Symbol, Integer] the parameter's value
+      # @return [void]
+      def []=(parameter_name, value)
+        ffi_value = value_to_ffi_value parameter_name, value
+        parameter_id = parameter_name_to_id(parameter_name)
+
+        if basic?
+          Libevoasm.x64_basic_params_set self, parameter_id, ffi_value
+        else
+          Libevoasm.x64_params_set self, parameter_id, ffi_value
+        end
+      end
+
+      private
+
+      def check_uint_range(value, bitsize)
+        min = 0
+        max = 2**bitsize - 1
+        raise ArgumentError, "#{value} exceeds value range #{min}..#{max}" if value < min || value > max
+
+        value
+      end
+
+      def check_int_range(value, bitsize)
+        min = -2**bitsize
+        max = -min - 1
+        raise ArgumentError, "#{value} exceeds value range #{min}..#{max}" if value < min || value > max
+
+        value
+      end
+
+      def parameter_type(parameter_name)
+        if basic?
+          Libevoasm.x64_basic_params_get_type(parameter_name)
+        else
+          Libevoasm.x64_params_get_type(parameter_name)
+        end
+      end
+
+      def value_to_ffi_value(parameter_name, parameter_value)
+        raise ArgumentError, 'value cannot be nil' if parameter_value.nil?
+
+        parameter_type = parameter_type parameter_name
+        ffi_value = @type_map[parameter_type][parameter_value]
+
+        if ffi_value.nil?
+          raise ArgumentError, "value #{parameter_value} is invalid for #{parameter_name}"
+        end
+
+        ffi_value
+      end
+
+      def ffi_value_to_value(parameter_name, ffi_value)
+        parameter_type = parameter_type parameter_name
+
+        if @type_map_enum_types.key? parameter_type
+          ffi_value = @type_map_enum_types[parameter_type][ffi_value]
+        end
+
+        @inv_type_map[parameter_type][ffi_value]
+      end
+
+      def parameter_name_to_id(symbol)
+        id = @param_id_enum_type[symbol]
+
+        if id.nil?
+          raise ArgumentError, "unknown parameter '#{symbol}'"
+        end
+
+        id
+      end
+    end
+  end
+end