ruby_apk 0.4.2 → 0.5.0

data/CHANGELOG.md

@@ -1,4 +1,7 @@
 # ChangeLog
+## 0.5.0
+* implement Android::Resource#find, #res_readable_id, #res_hex_id methods
+
 ## 0.4.2
 * fix bugs(#2, #3)
 * divide change log from readme

data/README.md

@@ -5,7 +5,7 @@ Android Apk static analysis library for Ruby.
 - ruby(>=1.9.x)
 
 ## Install
-  $ gem install ruby_apk
+    $ gem install ruby_apk
 
 ## Usage
 ### Initialize
@@ -72,6 +72,22 @@ end
   rsc = Android::Resource.new(rsc_data)
 ```
 
+### Resolve resource id
+This feature supports only srting resources for now.
+
+```ruby
+  apk = Android::Apk.new('sample.apk')
+  # assigns readable resource id
+  puts rsc.find('@string/app_name') # => 'application name'
+
+  # assigns hex resource id
+  puts rsc.find('@0x7f040000') # => 'application name'
+
+  # you can set lang attribute.
+  puts rsc.find('@0x7f040000', :lang => 'ja')
+```
+
+
 ### Dex
 #### Extract dex information
 ```ruby

data/VERSION

@@ -1 +1 @@
-0.4.2
+0.5.0

data/lib/android/resource.rb

@@ -1,26 +1,22 @@
 # encoding: utf-8
 require 'stringio'
-require 'csv'
-require 'ruby_apk'
 
 module Android
   # based on Android OS source code
   # /frameworks/base/include/utils/ResourceTypes.h
+  # @see http://justanapplication.wordpress.com/category/android/android-resources/
   class Resource
-    class ChunkHeader
-      attr_reader :type, :header_size, :size
+    class Chunk
       def initialize(data, offset)
         @data = data
         @offset = offset
+        exec_parse
+      end
+      def exec_parse
         @data_io = StringIO.new(@data, 'rb')
-        @data_io.seek(offset)
+        @data_io.seek(@offset)
         parse
-      end
-      private
-      def parse
-        @type = read_int16
-        @header_size = read_int16
-        @size = read_int32
+        @data_io.close
       end
       def read_int32
         @data_io.read(4).unpack('V')[0]
@@ -28,6 +24,22 @@ module Android
       def read_int16
         @data_io.read(2).unpack('v')[0]
       end
+      def read_int8
+        @data_io.read(1).ord
+      end
+      def current_position
+        @data_io.pos
+      end
+    end
+
+    class ChunkHeader < Chunk
+      attr_reader :type, :header_size, :size
+      private
+      def parse
+        @type = read_int16
+        @header_size = read_int16
+        @size = read_int32
+      end
     end
 
     class ResTableHeader < ChunkHeader
@@ -37,6 +49,7 @@ module Android
         @package_count = read_int32
       end
     end
+
     class ResStringPool < ChunkHeader
       SORTED_FLAG = 1 << 0
       UTF8_FLAG = 1 << 8
@@ -95,37 +108,407 @@ module Android
       end
     end
 
+    class ResTablePackage < ChunkHeader
+      attr_reader :name
+
+      def global_string_pool=(pool)
+        @global_string_pool = pool
+        extract_res_strings
+      end
+
+      # find resource by resource id
+      # @param [String] res_id (like '@0x7f010001' or '@string/key')
+      # @param [Hash] opts option
+      # @option opts [String] :lang language code like 'ja', 'cn'...
+      # @option opts [String] :contry cantry code like 'jp'...
+      # @raise [ArgumentError] invalid id format
+      # @note
+      #  This method only support string resource for now.
+      # @note
+      #  Always return nil if assign not string type res id.
+      #
+      def find(res_id, opts={})
+        hex_id = strid2int(res_id)
+        tid = ((hex_id&0xff0000) >>16)
+        key = hex_id&0xffff
+
+        if type(tid) == 'string'
+          return find_res_string(key, opts)
+        else
+          nil
+        end
+      end
+
+      def find_res_string(key, opts={})
+        unless opts[:lang].nil?
+          string = @res_strings_lang[opts[:lang]]
+        end
+        unless opts[:contry].nil?
+          string = @res_strings_contry[opts[:contry]]
+        end
+        string = @res_strings_default if string.nil?
+        raise NotFoundError unless string.has_key? key
+        return string[key]
+      end
+      private :find_res_string
+
+      # convert string resource id to fixnum
+      # @param [String] res_id (like '@0x7f010001' or '@string/key')
+      # @return [Fixnum] integer id (like 0x7f010001)
+      # @raise [ArgumentError] invalid format
+      def strid2int(res_id)
+        case res_id
+        when /^@?0x[0-9a-fA-F]{8}$/
+          return res_id.sub(/^@/,'').to_i(16)
+        when /^@?\w+\/\w+/
+          return res_hex_id(res_id).sub(/^@/,'').to_i(16)
+        else
+          raise ArgumentError
+        end
+      end
+
+      def res_readable_id(hex_id)
+        if hex_id.kind_of? String
+          hex_id = hex_id.sub(/^@/,'').to_i(16)
+        end
+        tid = ((hex_id&0xff0000) >>16)
+        key = hex_id&0xffff
+        raise NotFoundError if !@types.has_key?(tid) || @types[tid][0][key].nil?
+        keyid= @types[tid][0][key].key # ugh!
+        "@#{type(tid)}/#{key(keyid)}"
+      end
+      def res_hex_id(readable_id, opt={})
+        dummy, typestr, keystr = readable_id.match(/^@?(\w+)\/(\w+)$/).to_a
+        tid = type_id(typestr)
+        raise NotFoundError unless @types.has_key?(tid)
+        keyid = @types[tid][0].keys[keystr]
+        raise NotFoundError if keyid.nil?
+        "@0x7f%02x%04x" % [tid, keyid]
+      end
+
+      def type_strings
+        @type_strings.strings
+      end
+      def type(id)
+        type_strings[id-1]
+      end
+      def type_id(str)
+        raise NotFoundError unless type_strings.include? str
+        type_strings.index(str) + 1
+      end
+      def key_strings
+        @key_strings.strings
+      end
+      def key(id)
+        key_strings[id]
+      end
+      def key_id(str)
+        raise NotFoundError unless key_strings.include? str
+        key_strings.index(str) 
+      end
+
+      def parse
+        super
+        @id = read_int32
+        @name = @data_io.read(256).force_encoding(Encoding::UTF_16LE)
+        @name.encode!(Encoding::UTF_8).strip!
+        type_strings_offset = read_int32
+        @type_strings = ResStringPool.new(@data, @offset + type_strings_offset)
+        @last_public_type = read_int32
+        key_strings_offset = read_int32
+        @key_strings = ResStringPool.new(@data, @offset + key_strings_offset)
+        @last_public_key = read_int32
+
+        offset = @offset + key_strings_offset + @key_strings.size
+
+        @types = {}
+        @specs = {}
+        while offset < (@offset + @size)
+          type = @data[offset, 2].unpack('v')[0]
+          case type
+          when 0x0201 # RES_TABLE_TYPE_TYPE
+            type = ResTableType.new(@data, offset, self)
+            offset += type.size
+            @types[type.id] = [] if @types[type.id].nil?
+            @types[type.id] << type
+          when 0x0202 # RES_TABLE_TYPE_SPEC_TYPE`
+            spec = ResTableTypeSpec.new(@data, offset)
+            offset += spec.size
+            @specs[spec.id] = [] if @specs[spec.id].nil?
+            @specs[spec.id] << spec
+          else
+            raise "chunk type error: type:%#04x" % type
+          end
+        end
+      end
+      private :parse
+
+      def extract_res_strings
+        @res_strings_lang = {}
+        @res_strings_contry = {}
+        begin
+          type = type_id('string')
+        rescue NotFoundError
+          return
+        end
+        @types[type_id('string')].each do |type|
+          str_hash  = {}
+          type.entry_count.times do |i|
+            entry = type[i]
+            if entry.nil?
+              str_hash[i] = nil
+            else
+              str_hash[i] = @global_string_pool.strings[type[i].val.data]
+            end
+          end
+          lang = type.config.locale_lang
+          contry = type.config.locale_contry
+          if lang.nil? && contry.nil?
+            @res_strings_default = str_hash
+          else
+            @res_strings_lang[lang] = str_hash unless lang.nil?
+            @res_strings_contry[contry] = str_hash unless contry.nil?
+          end
+        end
+      end
+      private :extract_res_strings
+
+      def inspect
+        "<ResTablePackage offset:%#08x, size:%#x, name:\"%s\">" % [@offset, @size, @name]
+      end
+    end
+
+    class ResTableType < ChunkHeader
+      attr_reader :id, :entry_count, :entry_start, :config
+      attr_reader :keys
+
+      def initialize(data, offset, pkg)
+        @pkg = pkg
+        super(data, offset)
+      end
+      # @param [String] index key name
+      # @param [Fixnum] index key index
+      # @return [ResTableEntry]
+      # @return [ResTableMapEntry]
+      # @return nil if entry index is NO_ENTRY(0xFFFFFFFF)
+      def [](index)
+        @entries[index]
+      end
+
+      def parse
+        super
+        @id = read_int8
+        res0 = read_int8   # must be 0.(maybe 4byte align)
+        res1 = read_int16  # must be 0.(maybe 4byte align)
+        @entry_count = read_int32
+        @entry_start = read_int32
+        @config = ResTableConfig.new(@data, current_position)
+        @data_io.seek(@config.size, IO::SEEK_CUR)
+
+        @entries = []
+        @keys = {}
+        @entry_count.times do |i|
+          entry_index = read_int32
+          if entry_index == ResTableEntry::NO_ENTRY
+            @entries << nil
+          else
+            entry = ResTableEntry.read_entry(@data, @offset + @entry_start + entry_index)
+            @entries << entry
+            @keys[@pkg.key(entry.key)] = i
+          end
+        end
+      end
+      private :parse
+
+
+      def inspect
+        "<ResTableType offset:0x#{@offset.to_s(16)}, id:#{@id}, " +
+        "count:#{@entry_count}, start:0x#{@entry_start.to_s(16)}>"
+      end
+    end
+
+    class ResTableConfig < Chunk
+      attr_reader :size, :imei, :locale_lang, :locale_contry, :input
+      attr_reader :screen_input, :version, :screen_config
+      def parse
+        @size = read_int32
+        @imei = read_int32
+        la = @data_io.read(2)
+        @locale_lang = la unless la == "\x00\x00"
+        cn = @data_io.read(2)
+        @locale_contry = cn unless cn == "\x00\x00"
+        @screen_type = read_int32
+        @input = read_int32
+        @screen_input = read_int32
+        @version = read_int32
+        @screen_config = read_int32
+      end
+      def inspect
+        "<ResTableConfig size:#{@size}, imei:#{@imei}, la:'#{@locale_lang}' cn:'#{@locale_contry}'"
+      end
+    end
+
+    class ResTableTypeSpec < ChunkHeader
+      attr_reader :id, :entry_count
+
+      def parse
+        super
+        @id = read_int8
+        res0 = read_int8 # must be 0.(maybe 4byte align)
+        res1 = read_int16 # must be 0.(maybe 4byte align)
+        @entry_count = read_int32
+      end
+      private :parse
+
+      def inspect
+        "<ResTableTypeSpec id:#{@id} entry count:#{@entry_count}>"
+      end
+    end
+    class ResTableEntry < Chunk
+      NO_ENTRY = 0xFFFFFFFF
+
+      # @return [ResTableEntry] if not set FLAG_COMPLEX
+      # @return [ResTableMapEntry] if not set FLAG_COMPLEX
+      def self.read_entry(data, offset)
+        flag = data[offset + 2, 2].unpack('v')[0]
+        if flag & ResTableEntry::FLAG_COMPLEX == 0
+          ResTableEntry.new(data, offset)
+        else
+          ResTableMapEntry.new(data, offset)
+        end
+      end
+
+      # If set, this is a complex entry, holding a set of name/value
+      # mappings.  It is followed by an array of ResTable_map structures.
+      FLAG_COMPLEX = 0x01
+      # If set, this resource has been declared public, so libraries
+      # are allowed to reference it.
+      FLAG_PUBLIC  = 0x02
+
+      attr_reader :size, :key, :val
+      def parse
+        @size = read_int16
+        @flag = read_int16
+        @key = read_int32 # RefStringPool_key
+        @val = ResValue.new(@data, current_position)
+      end
+      private :parse
+
+      def inspect
+        "<ResTableEntry @size=#{@size}, @key=#{@key} @flag=#{@flag}>"
+      end
+    end
+    class ResTableMapEntry < ResTableEntry
+      attr_reader :parent, :count
+      def parse
+        super
+        # resource identifier of the parent mapping, 0 if there is none.
+        @parent = read_int32
+        # number of name/value pairs that follw for FLAG_COMPLEX
+        @count = read_int32
+        # TODO: implement read ResTableMap object
+      end
+      private :parse
+    end
+    class ResTableMap < Chunk
+      def size
+        @val.size + 4
+      end
+      def parse
+        @name = read_int32
+       @val = ResValue.new(@data, current_position)
+      end
+    end
+
+    class ResValue < Chunk
+      attr_reader :size, :data_type, :data
+      def parse
+        @size = read_int16
+        res0 = read_int8 # Always set 0.
+        @data_type = read_int8
+        @data = read_int32
+      end
+      private :parse
+    end
+
     ######################################################################
+    # @returns [Hash] { name(String) => value(ResTablePackage) }
+    attr_reader :packages
+
     def initialize(data)
       data.force_encoding(Encoding::ASCII_8BIT)
       @data = data
       parse()
     end
 
+
+    # @return [Array<String>] all strings defined in arsc.
     def strings
       @string_pool.strings
     end
+
+    # @return [Fixnum] number of packages
     def package_count
       @res_table.package_count
     end
 
+    #  This method only support string resource for now.
+    # find resource by resource id
+    # @param [String] res_id (like '@0x7f010001' or '@string/key')
+    # @param [Hash] opts option
+    # @option opts [String] :lang language code like 'ja', 'cn'...
+    # @option opts [String] :contry cantry code like 'jp'...
+    # @raise [ArgumentError] invalid id format
+    # @note
+    #  This method only support string resource for now.
+    # @note
+    #  Always return nil if assign not string type res id.
+    # @since 0.5.0
+    def find(rsc_id, opt={})
+      first_pkg.find(rsc_id, opt)
+    end
+
+    # @param [String] hex_id hexoctet format resource id('@0x7f010001')
+    # @return [String] readable resource id ('@string/key')
+    # @since 0.5.0
+    def res_readable_id(hex_id)
+      first_pkg.res_readable_id(hex_id)
+    end
+
+    # convert readable resource id to hex id
+    # @param [String] readable_id readable resource id ('@string/key')
+    # @return [String] hexoctet format resource id('@0x7f010001')
+    # @since 0.5.0
+    def res_hex_id(readable_id)
+      first_pkg.res_hex_id(readable_id)
+    end
+
     private
+    def first_pkg
+      @packages.first[1]
+    end
     def parse
       offset = 0
 
       while offset < @data.size
         type = @data[offset, 2].unpack('v')[0]
+        #print "[%#08x] " % offset
+        @packages = {}
         case type
         when 0x0001 # RES_STRING_POOL_TYPE
           @string_pool = ResStringPool.new(@data, offset)
           offset += @string_pool.size
+          #puts "RES_STRING_POOL_TYPE %#x, %#x" % [@string_pool.size, offset]
         when 0x0002 # RES_TABLE_TYPE
+          #puts "RES_TABLE_TYPE"
           @res_table = ResTableHeader.new(@data, offset)
           offset += @res_table.header_size
-        when 0x0200, 0x0201, 0x0202
-          # not implemented yet.
-          chunk = ChunkHeader.new(@data, offset)
-          offset += chunk.size
+        when 0x0200 # RES_TABLE_PACKAGE_TYPE
+          #puts "RES_TABLE_PACKAGE_TYPE"
+          pkg = ResTablePackage.new(@data, offset)
+          pkg.global_string_pool = @string_pool
+          offset += pkg.size
+          @packages[pkg.name] = pkg
         else
           raise "chunk type error: type:%#04x" % type
         end

data/ruby_apk.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "ruby_apk"
-  s.version = "0.4.2"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["SecureBrain"]
-  s.date = "2012-12-19"
+  s.date = "2013-01-04"
   s.description = "static analysis tool for android apk"
   s.email = "info@securebrain.co.jp"
   s.extra_rdoc_files = [
@@ -44,6 +44,7 @@ Gem::Specification.new do |s|
     "spec/data/sample_classes.dex",
     "spec/data/sample_resources.arsc",
     "spec/data/sample_resources_utf16.arsc",
+    "spec/data/str_resources.arsc",
     "spec/dex/access_flag_spec.rb",
     "spec/dex/dex_object_spec.rb",
     "spec/dex/info_spec.rb",
@@ -58,7 +59,7 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/SecureBrain/ruby_apk/"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.24"
+  s.rubygems_version = "1.8.23"
   s.summary = "static analysis tool for android apk"
 
   if s.respond_to? :specification_version then

data/spec/resource_spec.rb

@@ -83,5 +83,74 @@ describe Android::Resource do
         end
       end
     end
+
+    context 'with str_resources.arsc data' do
+      let(:res_data) { File.read(File.expand_path(File.dirname(__FILE__) + '/data/str_resources.arsc')) }
+      subject { resource }
+      describe '#packages' do
+        subject {resource.packages}
+        it { should be_instance_of Hash}
+        it { subject.size.should eq 1 }
+      end
+      describe 'ResTablePackage' do
+        subject { resource.packages.first[1] }
+        it { subject.type(1).should eq 'attr' }
+        it { subject.type(4).should eq 'string' }
+        it { subject.name.should eq 'com.example.sample.ruby_apk' }
+      end
+      describe '#find' do
+        it '@0x7f040000 should return "sample.ruby_apk"' do
+          subject.find('@0x7f040000').should eq 'sample application'
+        end
+        it '@string/app_name should return "sample.ruby_apk"' do
+          subject.find('@string/app_name').should eq 'sample application'
+        end
+        it '@string/hello_world should return "Hello world!"' do
+          subject.find('@string/hello_world').should eq 'Hello world!'
+        end
+        it '@string/app_name should return "sample.ruby_apk"' do
+          subject.find('@string/app_name').should eq 'sample application'
+        end
+        it '@string/app_name with {:lang => "ja"} should return "サンプルアプリ"' do
+          subject.find('@string/app_name', :lang => 'ja').should eq 'サンプルアプリ'
+        end
+        it '@string/hello_world with {:lang => "ja"} should return nil' do
+          subject.find('@string/hello_world', :lang => 'ja').should be_nil
+        end
+        context 'assigns not exist string resource id' do
+          it {  expect {subject.find('@string/not_exist') }.to raise_error Android::NotFoundError }
+          it {  expect {subject.find('@0x7f040033') }.to raise_error Android::NotFoundError }
+        end
+        context 'assigns not string resource id' do
+          it { subject.find('@layout/activity_main').should be_nil }
+        end
+        context 'assigns invalid format id' do
+          it '"@xxyyxxyy" should raise ArgumentError' do
+            expect{ subject.find('@xxyyxxyy') }.to raise_error(ArgumentError)
+          end
+          it '"@0xff112233445566" should raise ArgumentError' do
+            expect{ subject.find('@0xff112233445566') }.to raise_error(ArgumentError) 
+          end
+        end
+      end
+      describe '#res_readable_id' do
+        it { subject.res_readable_id('@0x7f040000').should eq '@string/app_name' }
+        context 'assigns invalid type' do
+          it { expect{subject.res_readable_id('@0x7f0f0000')}.to raise_error Android::NotFoundError }
+        end
+        context 'assigns invalid key' do
+          it { expect{subject.res_readable_id('@0x7f040033')}.to raise_error Android::NotFoundError }
+        end
+      end
+      describe '#res_hex_id' do
+        it { subject.res_hex_id('@string/app_name').should eq '@0x7f040000' }
+        context 'assigns invalid type' do
+          it { expect{subject.res_readable_id('@not_exist/xxxx')}.to raise_error Android::NotFoundError }
+        end
+        context 'assigns invalid key' do
+          it { expect{subject.res_readable_id('@string/not_exist')}.to raise_error Android::NotFoundError }
+        end
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_apk
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-19 00:00:00.000000000 Z
+date: 2013-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -158,6 +158,7 @@ files:
 - spec/data/sample_classes.dex
 - spec/data/sample_resources.arsc
 - spec/data/sample_resources_utf16.arsc
+- spec/data/str_resources.arsc
 - spec/dex/access_flag_spec.rb
 - spec/dex/dex_object_spec.rb
 - spec/dex/info_spec.rb
@@ -183,7 +184,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1781742787123284542
+      hash: 671022741244016522
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -192,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: static analysis tool for android apk