android_parser 2.4.1

data/lib/android/axml_writer.rb

@@ -0,0 +1,49 @@
+require 'rexml/document'
+require 'stringio'
+
+module Android
+  class AXMLWriter < AXMLParser
+    # @param [String] axml binary xml data
+    def initialize(axml)
+      @io = StringIO.new(axml, "r+b")
+      @strings = []
+    end
+
+    def modify_metadata!(name, new_value)
+      parse if @doc.nil?
+
+      entry = @metadata.find { |meta| meta['android:name'][:value] == name }
+      raise "Metadata #{name} could not be found and modified" if entry.nil?
+
+      pos = if entry['android:value'][:is_string]
+              new_string_id = add_string!(new_value)
+              new_value = new_string_id
+              entry['android:value'][:val_str_id]
+            else
+              entry['android:value'][:position]
+            end
+
+      @io.pos = pos
+      @io.write([new_value].pack('V'))
+    end
+
+    def add_string!(str)
+      new_string_id, bytes_added = Resource::ResStringPool.new(@io.string, 8).add_string(str)
+
+      # Update XML size and positions of metadata attributes.
+      @io.pos = 4
+      xml_size = @io.read(4).unpack1('V')
+      @io.pos = 4
+      @io.write([xml_size + bytes_added].pack('V'))
+
+      @metadata = @metadata.map do |metadata|
+        metadata.transform_values do |attribute|
+          attribute[:position] += bytes_added
+          attribute[:val_str_id] += bytes_added
+          attribute
+        end
+      end
+      new_string_id
+    end
+  end
+end

data/lib/android/dex/access_flag.rb

@@ -0,0 +1,74 @@
+
+module Android
+  class Dex
+    # access flag object
+    class AccessFlag
+      # @return [Integer] flag value
+      attr_reader :flag
+      def initialize(flag)
+        @flag = flag
+      end
+    end
+
+    # access flag object for class in dex
+    class ClassAccessFlag < AccessFlag
+      ACCESSORS = [
+        {value:0x1,     name:'public'},
+        {value:0x2,     name:'private'},
+        {value:0x4,     name:'protected'},
+        {value:0x8,     name:'static'},
+        {value:0x10,    name:'final'},
+        {value:0x20,    name:'synchronized'},
+        {value:0x40,    name:'volatile'},
+        {value:0x80,    name:'transient'},
+        {value:0x100,   name:'native'},
+        {value:0x200,   name:'interface'},
+        {value:0x400,   name:'abstract'},
+        {value:0x800,   name:'strict'},
+        {value:0x1000,  name:'synthetic'},
+        {value:0x2000,  name:'annotation'},
+        {value:0x4000,  name:'enum'},
+        #{value:0x8000,  name:'unused'},
+        {value:0x10000, name:'constructor'},
+        {value:0x20000, name:'declared-synchronized'},
+      ]
+
+      # convert access flag to string
+      # @return [String]
+      def to_s
+        ACCESSORS.select{|e| ((e[:value] & @flag) != 0) }.map{|e| e[:name] }.join(' ')
+      end
+    end
+   
+    # access flag object for method in dex
+    class MethodAccessFlag < AccessFlag
+      ACCESSORS = [
+        {value: 0x1,     name:'public'},
+        {value: 0x2,     name:'private'},
+        {value: 0x4,     name:'protected'},
+        {value: 0x8,     name:'static'},
+        {value: 0x10,    name:'final'},
+        {value: 0x20,    name:'synchronized'},
+        {value: 0x40,    name:'bridge'},
+        {value: 0x80,    name:'varargs'},
+        {value: 0x100,   name:'native'},
+        {value: 0x200,   name:'interface'},
+        {value: 0x400,   name:'abstract'},
+        {value: 0x800,   name:'strict'},
+        {value: 0x1000,  name:'synthetic'},
+        {value: 0x2000,  name:'annotation'},
+        {value: 0x4000,  name:'enum'},
+        #{value: 0x8000,  name:'unused'},
+        {value: 0x10000, name:'constructor'},
+        {value: 0x20000, name:'declared-synchronized'},
+      ]
+      # convert access flag to string
+      # @return [String]
+      def to_s
+        ACCESSORS.select{|e| ((e[:value] & @flag) != 0) }.map{|e| e[:name] }.join(' ')
+      end
+    end
+  end
+end
+
+

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