ruby_android 0.0.2 → 0.7.2

data/lib/android/dex/dex_object.rb

@@ -0,0 +1,475 @@
+
+module Android
+  class Dex
+    # parsing dex object
+    # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+    class DexObject
+      # @return [Integer] object size
+      attr_reader :size
+
+      def initialize(data, offset)
+        @data = data
+        @offset = offset
+
+        @params = {}
+        @parsing_off = 0 # parsing offset
+        parse()
+        @size = @parsing_off
+      end
+ 
+      # returns symbol keys
+      # @return [Array<Symbol>] header key
+      def symbols
+        @params.keys
+      end
+
+      # @param [Symbol] sym should be included in #symbols
+      # @return [Object] dex header value which is related with sym
+      def [](sym)
+        @params[sym.to_sym]
+      end
+
+      # @return [String]
+      def inspect
+        str = "<#{self.class}\n"
+        @params.each  do |key,val|
+          str.concat "    #{key}: #{val}\n"
+        end
+        str.concat '>'
+      end
+
+      private
+      def parse
+        raise 'this method should be overloaded.'
+      end
+
+      def read_value(type)
+        types = {
+          :byte   => [1, 'c'],
+          :ubyte  => [1, 'C'],
+          :short  => [2, 's'], #ugh!:depend on machine endian
+          :ushort => [2, 'v'],
+          :int    => [4, 'i'], #ugh!:depend on machine endian
+          :uint   => [4, 'V'],
+          :long   => [8, 'q'],
+          :ulong  => [8, 'Q'],
+        }
+        len, pack_str = types.fetch(type)
+        value = @data[@offset+@parsing_off, len].unpack(pack_str)[0]
+        @parsing_off += len
+        return value
+      end
+
+      # read short int from data buffer
+      # @return [Integer] short value
+      def read_sleb
+        value, len = Dex::sleb128(@data, @offset + @parsing_off)
+        @parsing_off += len
+        value
+      end
+      # read integer from data buffer
+      # @return [Integer] integer value
+      def read_uleb
+        value, len = Dex::uleb128(@data, @offset + @parsing_off)
+        @parsing_off += len
+        value
+      end
+      # read integer from data buffer and plus 1
+      # @return [Integer] integer value
+      def read_uleb128p1
+        value, len = Dex::uleb128p1(@data, @offset + @parsing_off)
+        @parsing_off += len
+        value
+      end
+      # read various values from data buffer as array
+      # @param [Symbol] type 
+      # @param [Integer] size num of data
+      # @return [Array] value array
+      def read_value_array(type, size)
+        ret_array = []
+        size.times { ret_array << read_value(type) }
+        ret_array
+      end
+      # read class values from data buffer as array
+      # @param [Class] cls target class
+      # @param [Integer] size num of data
+      # @return [Array<cls>] object array
+      def read_class_array(cls, size)
+        ret_array = []
+        size.times do
+          item = cls.new(@data, @offset + @parsing_off)
+          ret_array << item
+          @parsing_off += item.size
+        end
+        ret_array
+      end
+
+      public
+      # header_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class Header < DexObject
+        def initialize(data)
+          super(data, 0)
+        end
+
+        private
+        def parse
+          @params[:magic] = @data[0, 8]
+          @parsing_off += 8
+          @params[:checksum] = read_value(:uint)
+          @params[:signature] = @data[12, 20]
+          @parsing_off += 20
+          [
+            :file_size, :header_size, :endian_tag, :link_size, :link_off, :map_off,
+            :string_ids_size, :string_ids_off, :type_ids_size, :type_ids_off,
+            :proto_ids_size, :proto_ids_off, :field_ids_size, :field_ids_off,
+            :method_ids_size, :method_ids_off, :class_defs_size, :class_defs_off,
+            :data_size, :data_off
+          ].each do |key|
+            @params[key] = read_value(:uint)
+          end
+        end
+      end
+
+      # map_list
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class MapList < DexObject
+        private
+        def parse
+          @params[:size] = read_value(:uint)
+          @params[:list] = read_class_array(MapItem, @params[:size])
+        end
+      end
+
+      # map_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class MapItem < DexObject
+        private
+        def parse
+          @params[:type] = read_value(:short)
+          @params[:unused] = read_value(:short)
+          @params[:size] = read_value(:uint)
+          @params[:offset] = read_value(:uint)
+        end
+      end
+
+      # id_list
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class IdsList < DexObject
+        attr_reader :ids_size
+        def initialize(data, off, ids_size)
+          @ids_size = ids_size
+          super(data, off)
+        end
+      end
+
+      # string_id_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class StringIdItem < IdsList
+        private
+        def parse
+          @params[:string_data_off] = read_value_array(:uint, @ids_size)
+        end
+      end
+
+      # string_data_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class StringDataItem < DexObject
+        def to_s
+          @params[:data]
+        end
+        private
+        def mutf8_to_utf8(data, off, ulen)
+          mi = 0 # index of mutf8 data
+          codepoints = []
+          while ulen > 0 do
+            b0 = data[off + mi].ord
+            bu = (b0 & 0xf0) # b0's upper nibble
+            if (b0 & 0x80) == 0 # single byte encoding (0b0xxx_xxxx)
+              c = b0
+              mi += 1
+              ulen -= 1
+            elsif bu == 0xc0 || bu == 0xd0 # two-byte encoding (0b110x_xxxx)
+              b1 = data[off + mi + 1].ord
+              c = (b0 & 0x1f) << 6 | (b1 & 0x3f)
+              mi += 2
+              ulen -= 1
+            elsif bu == 0xe0 # three-byte encoding (0b1110_xxxx)
+              b1 = data[off + mi + 1].ord
+              b2 = data[off + mi + 2].ord
+              c = (b0 & 0x0f) << 12 | (b1 & 0x3f) << 6 | (b2 & 0x3f)
+              mi += 3
+              ulen -= 1
+              if 0xD800 <= c && c <= 0xDBFF  # this must be a surrogate pair
+                b4 = data[off + mi + 1].ord
+                b5 = data[off + mi + 2].ord
+                c = ((b1 & 0x0f) + 1) << 16 | (b2 & 0x3f) << 10 | (b4 & 0x0f) << 6 | (b5 & 0x3f)
+                mi += 3
+                ulen -= 1
+              end
+            else
+              STDERR.puts "unsupported byte: 0x#{'%02X' % b0} @#{mi}"
+              c = 0
+              mi += 1
+              next
+            end
+            if c != 0
+              codepoints << c
+            end
+          end
+          codepoints.pack("U*")
+        end
+        def parse
+          @params[:utf16_size] = read_uleb
+          @params[:data] = mutf8_to_utf8(@data, @offset + @parsing_off, @params[:utf16_size])
+        end
+      end
+
+      # type_id_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class TypeIdItem < IdsList
+        def [](idx)
+          raise ArgumentError if idx >= @params[:descriptor_idx].size or idx < 0
+          @params[:descriptor_idx][idx]
+        end
+
+        private
+        def parse
+          @params[:descriptor_idx] = read_value_array(:uint, @ids_size)
+        end
+      end
+
+      # proto_id_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class ProtoIdItem < DexObject
+        # return parse data size
+        # @return bytes
+        # @note this method for DexObject#read_class_array (private method)
+        def self.size
+          4 * 3
+        end
+        private
+        def parse
+          @params[:shorty_idx] = read_value(:uint)
+          @params[:return_type_idx] = read_value(:uint)
+          @params[:parameters_off] = read_value(:uint)
+        end
+      end
+
+      # field_id_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class FieldIdItem < DexObject
+        # return parse data size
+        # @return bytes
+        # @note this method for DexObject#read_class_array (private method)
+        def self.size
+          2 * 2 + 4 
+        end
+        private
+        def parse
+          @params[:class_idx] = read_value(:ushort)
+          @params[:type_idx] = read_value(:ushort)
+          @params[:name_idx] = read_value(:uint)
+        end
+      end
+
+      # method_id_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class MethodIdItem < DexObject
+        # return parse data size
+        # @return bytes
+        # @note this method for DexObject#read_class_array (private method)
+        def self.size
+          2 * 2 + 4 
+        end
+        def parse
+          @params[:class_idx] = read_value(:ushort)
+          @params[:proto_idx] = read_value(:ushort)
+          @params[:name_idx] = read_value(:uint)
+        end
+      end
+
+      # class_def_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      # @!attribute [r] class_data_item
+      #  @return [ClassDataItem] class_data_item of this class
+      class ClassDefItem < DexObject
+        # @return [Integer] bytes
+        def self.size
+          4 * 8
+        end
+
+        def class_data_item
+          # description of class_data_off of class_def_item.
+          #   offset from the start of the file to the associated class data
+          #   for this item, or 0 if there is no class data for this class.
+          if @params[:class_data_off] != 0
+            @class_data_item ||= ClassDataItem.new(@data, @params[:class_data_off])
+          else
+            nil
+          end
+        end
+
+        private
+        def parse
+          @params[:class_idx] = read_value(:uint)
+          @params[:access_flags] = read_value(:uint)
+          @params[:superclass_idx] = read_value(:uint)
+          @params[:interfaces_off] = read_value(:uint)
+          @params[:source_file_idx] = read_value(:uint)
+          @params[:annotations_off] = read_value(:uint)
+          @params[:class_data_off] = read_value(:uint)
+          @params[:static_values_off] = read_value(:uint) # TODO: not implemented encoded_array_item
+        end
+      end
+
+      # class_data_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class ClassDataItem < DexObject
+        private
+        def parse
+          @params[:static_fields_size] = read_uleb
+          @params[:instance_fields_size] = read_uleb
+          @params[:direct_methods_size] = read_uleb
+          @params[:virtual_methods_size] = read_uleb
+          @params[:static_fields] = read_class_array(EncodedField, @params[:static_fields_size])
+          @params[:instance_fields] = read_class_array(EncodedField, @params[:instance_fields_size])
+          @params[:direct_methods] = read_class_array(EncodedMethod, @params[:direct_methods_size])
+          @params[:virtual_methods] = read_class_array(EncodedMethod, @params[:virtual_methods_size])
+        end
+      end
+
+      # encoded_field
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class EncodedField < DexObject
+        private
+        def parse
+          @params[:field_idx_diff] = read_uleb
+          @params[:access_flags] = read_uleb
+        end
+      end
+
+      # encoded_method
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      # @!attribute [r] code_item
+      #  @return [CodeItem] code_item of the method
+      class EncodedMethod < DexObject
+        def code_item
+          # description of code_off in code_data_item.
+          #   offset from the start of the file to the code structure for this method,
+          #   or 0 if this method is either abstract or native.
+          unless @params[:code_off] == 0
+            @code_item ||= CodeItem.new(@data, @params[:code_off])
+          else
+            nil
+          end
+        end
+
+        private
+        def parse
+          @params[:method_idx_diff] = read_uleb
+          @params[:access_flags] = read_uleb
+          @params[:code_off] = read_uleb
+        end
+      end
+
+
+      # type_list
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class TypeList < DexObject
+        private
+        def parse
+          @params[:size] = read_value(:uint)
+          @params[:list] = read_value_array(:ushort, @params[:size])
+        end
+      end
+
+      # code_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      # @!attribute [r] debug_info_item
+      #  @return [DebugInfoItem] debug_info_item of this code
+      class CodeItem < DexObject
+        def debug_info_item
+          unless @params[:debug_info_off] == 0
+            @debug_info_item ||= DebugInfoItem.new(@data, @params[:debug_info_off])
+          else
+            nil
+          end
+        end
+
+        private
+        def parse
+          @params[:registers_size] = read_value(:ushort)
+          @params[:ins_size] = read_value(:ushort)
+          @params[:outs_size] = read_value(:ushort)
+          @params[:tries_size] = read_value(:ushort)
+          @params[:debug_info_off] = read_value(:uint)
+          @params[:insns_size] = read_value(:uint) # size of the instructions list
+          @params[:insns] = read_value_array(:ushort, @params[:insns_size])
+          read_value(:ushort) if ((@params[:insns_size] % 2) == 1) # for four-byte aligned
+          if @params[:tries_size] > 0
+            # This element is only present if tries_size is non-zero.
+            @params[:tries] = read_class_array(TryItem, @params[:tries_size])
+            # This element is only present if tries_size is non-zero.
+            @params[:handlers] = EncodedCatchHandlerList.new(@data, @offset + @parsing_off)
+            @parsing_off += @params[:handlers].size
+          end
+        end
+      end
+
+      # try_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class TryItem < DexObject
+        private
+        def parse
+          @params[:start_addr] = read_value(:uint)
+          @params[:insn_count] = read_value(:ushort)
+          @params[:handler_off] = read_value(:ushort)
+        end
+      end
+
+      # encoded_catch_handler_list
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class EncodedCatchHandlerList < DexObject
+        private
+        def parse
+          @params[:size] = read_uleb
+          @params[:list] = read_class_array(EncodedCatchHandler, @params[:size])
+        end
+      end
+
+      # encoded_catch_handler
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class EncodedCatchHandler < DexObject
+        private
+        def parse
+          @params[:size] = read_sleb
+          @params[:list] = read_class_array(EncodedTypeAddrPair, @params[:size].abs)
+          @params[:catch_all_addr] = read_uleb if @params[:size] <= 0
+        end
+      end
+
+      # encoded_type_addr_pair
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class EncodedTypeAddrPair < DexObject
+        private
+        def parse
+          @params[:type_idx] = read_uleb
+          @params[:addr] = read_uleb
+        end
+      end
+
+      # debug_info_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class DebugInfoItem < DexObject
+        private
+        def parse
+          @params[:line_start] = read_uleb
+          @params[:parameters_size] = read_uleb
+          @params[:parameter_names] = []
+          @params[:parameters_size].times { @params[:parameter_names] << read_uleb128p1 }
+        end
+      end
+    end
+  end
+end

data/lib/android/dex/info.rb

@@ -0,0 +1,151 @@
+require_relative 'dex_object'
+
+module Android
+  class Dex
+    # class information in dex
+    # @!attribute [r] name
+    #  @return [String] class name
+    # @!attribute [r] super_class
+    #  @return [String] super class name
+    class ClassInfo
+      # no index flag
+      NO_INDEX = 0xffffffff
+
+      # @return [ClassAccessFlag]
+      attr_reader :access_flags
+      # @return [Array<FieldInfo>] static fields
+      attr_reader :static_fields
+      # @return [Array<FieldInfo>] instance fields
+      attr_reader :instance_fields
+      # @return [Array<MethodInfo>] direct methods
+      attr_reader :direct_methods
+      # @return [Array<MethodInfo>] virtual methods
+      attr_reader :virtual_methods
+
+      # @return [DexObject::ClassDataItem]
+      attr_reader :class_data
+      # @return [DexObject::ClassDefItem]
+      attr_reader :class_def
+
+      def name
+        @dex.type_resolve(@class_def[:class_idx])
+      end
+      def super_class
+        if @class_def[:superclass_idx] != NO_INDEX
+          @super_class = @dex.type_resolve(@class_def[:superclass_idx]) 
+        else
+          nil
+        end
+      end
+      # @param [Dex::ClassDefItem] class_def
+      # @param [Dex] dex dex class instance
+      def initialize(class_def, dex)
+        @class_def = class_def
+        @dex = dex
+        @access_flags = ClassAccessFlag.new(@class_def[:access_flags])
+        @class_data = @class_def.class_data_item
+        @static_fields = @instance_fields = @direct_methods = @virtual_methods = []
+        unless @class_data.nil?
+          @static_fields = cls2info(@class_data[:static_fields], FieldInfo, :field_idx_diff)
+          @instance_fields = cls2info(@class_data[:instance_fields], FieldInfo, :field_idx_diff)
+          @direct_methods = cls2info(@class_data[:direct_methods], MethodInfo, :method_idx_diff)
+          @virtual_methods = cls2info(@class_data[:virtual_methods], MethodInfo, :method_idx_diff)
+        end
+      end
+
+      # @return [String] class difinition
+      def definition
+        ret = "#{access_flags} class #{name}"
+        super_class.nil? ? ret : ret + " extends #{super_class}"
+      end
+
+      private
+      def cls2info(arr, cls, idx_key)
+        idx = 0
+        ret = []
+        arr.each do |item|
+          idx += item[idx_key]
+          ret << cls.new(item, idx, @dex)
+        end
+        ret
+      end
+    end
+
+    # field info object
+    # @!attribute [r] name
+    #  @return [String] field name
+    # @!attribute [r] type
+    #  @return [String] field type
+    class FieldInfo
+      # @return [ClassAccessFlag]
+      attr_reader :access_flags
+
+      def name
+        @dex.strings[@dex.field_ids[@field_id][:name_idx]]
+      end
+      def type
+        @dex.type_resolve(@dex.field_ids[@field_id][:type_idx])
+      end
+      def initialize(encoded_field, field_id, dex)
+        @dex = dex
+        @encoded_field = encoded_field
+        @field_id = field_id
+        @access_flags = ClassAccessFlag.new(encoded_field[:access_flags])
+      end
+
+      # @return [String] field definition
+      def definition
+        "#{@access_flags.to_s} #{type} #{name}"
+      end
+    end
+
+    # method info object
+    # @!attribute [r] name
+    #  @return [String] method name
+    # @!attribute [r] ret_type
+    #  @return [String] return type of the method
+    # @!attribute [r] parameters
+    #  @return [Array<String>] method parameters
+    class MethodInfo
+      # @return [MethodAccessFlag]
+      attr_reader :access_flags
+
+      def initialize(encoded_method, method_id, dex)
+        @encoded_method = encoded_method
+        @method_id = method_id
+        @dex = dex
+        @access_flags = MethodAccessFlag.new(encoded_method[:access_flags])
+      end
+      def name
+        @dex.strings[@dex.method_ids[@method_id][:name_idx]]
+      end
+      def ret_type
+        @dex.type_resolve(proto[:return_type_idx])
+      end
+      def parameters
+        unless proto[:parameters_off] == 0
+          list = DexObject::TypeList.new(@dex.data, proto[:parameters_off])
+          list[:list].map { |item| @dex.type_resolve(item) }
+        else
+          []
+        end
+      end
+
+      # @return [String] method definition string
+      def definition
+        "#{access_flags.to_s} #{ret_type} #{name}(#{parameters.join(', ')});"
+      end
+
+      # @return [DexObject::CodeItem]
+      def code_item
+        @encoded_method.code_item
+      end
+
+      private
+      def proto
+        @dex.proto_ids[@dex.method_ids[@method_id][:proto_idx]]
+      end
+    end
+
+  end
+end

data/lib/android/dex/utils.rb

@@ -0,0 +1,45 @@
+module Android
+  class Dex
+    class << self
+      # parse uleb128(unsigned integer) data
+      # @param [String] data target byte data
+      # @param [Integer] offset 
+      # @return [Integer, Integer] parsed value and parsed byte length
+      # @see http://en.wikipedia.org/wiki/LEB128
+      def uleb128(data, offset=0)
+        result = 0
+        shift = 0
+        d = data[offset...data.size]
+        (0..4).each do |i|
+          byte = d.getbyte(i)
+          result |= ((byte & 0x7f) << shift)
+          return result, i+1 if ((byte & 0x80) == 0)
+          shift += 7
+        end
+      end
+      # parse uleb128 + 1 data
+      # @param [String] data target byte data
+      # @param [Integer] offset 
+      # @return [Integer, Integer] parsed value and parsed byte length
+      def uleb128p1(data, offset=0)
+        ret, len = self.uleb128(data, offset)
+        return (ret - 1), len
+      end
+      # parse sleb128(signed integer) data
+      # @param [String] data target byte data
+      # @param [Integer] offset 
+      # @return [Integer, Integer] parsed value and parsed byte length
+      def sleb128(data, offset=0)
+        result  = 0
+        shift = 0
+        d = data[offset...data.size]
+        (0..4).each do |i|
+          byte  = d.getbyte(i)
+          result  |=((byte & 0x7F) << shift)
+          return (0 == (byte & 0x40) ? result : result - (1 << (shift+7))), i+1 if ((byte & 0x80) == 0)
+          shift += 7
+        end
+      end
+    end
+  end
+end