apktools 0.1.0

data/lib/apktools/apkresources.rb

@@ -0,0 +1,586 @@
+# Copyright (C) 2012 Dave Smith
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this
+# software and associated documentation files (the "Software"), to deal in the Software
+# without restriction, including without limitation the rights to use, copy, modify,
+# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies
+# or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require 'zip/zip'
+
+##
+# Class to parse an APK's resources.arsc data and retrieve resource
+# data associated with a given R.id value
+class ApkResources
+
+	DEBUG = false # :nodoc:
+	
+	##
+	# Structure defining the type and size of each resource chunk
+	#
+	# ChunkHeader = Struct.new(:type, :size, :chunk_size)
+	ChunkHeader = Struct.new(:type, :size, :chunk_size)
+	
+	##
+	# Structure that houses a group of strings
+	#
+	# StringPool = Struct.new(:header, :string_count, :style_count, :values)
+	#
+	# * +header+ = ChunkHeader
+	# * +string_count+ = Number of normal strings in the pool
+	# * +style_count+ = Number of styled strings in the pool
+	# * +values+ = Array of the string values
+	StringPool = Struct.new(:header, :string_count, :style_count, :values)
+	
+	##
+	# Structure defining the data inside of the package chunk
+	#
+	# PackageHeader = Struct.new(:header, :id, :name, :type_strings, :key_strings)
+	#
+	# * +header+ = ChunkHeader
+	# * +id+ = Package id; usually 0x7F for application resources
+	# * +name+ = Package name (e.g. "com.example.application")
+	# * +type_strings+ = Array of the type string values present (e.g. "drawable")
+	# * +key_strings+ = Array of the key string values present (e.g. "ic_launcher")
+	PackageHeader = Struct.new(:header, :id, :name, :type_strings, :key_strings)
+	
+	##
+	# Structure defining the flags for a block of common resources
+	#
+	# ResTypeSpec = Struct.new(:header, :id, :entry_count, :entries, :types)
+	#
+	# * +header+ = ChunkHeader
+	# * +id+ = String value of the referenced type (e.g. "drawable")
+	# * +entry_count+ = Number of type entries in this chunk
+	# * +entries+ = Array of config flags for each type entry
+	# * +types+ = The ResType associated with this spec
+	ResTypeSpec = Struct.new(:header, :id, :entry_count, :entries, :types)
+	
+	##
+	# Structure that houses all the resources for a given type
+	#
+	# ResType = Struct.new(:header, :id, :config, :entry_count, :entries)
+	#
+	# * +header+ = ChunkHeader
+	# * +id+ = String value of the referenced type (e.g. "drawable")
+	# * +config+ = ResTypeConfig defining the configuration for this type
+	# * +entry_count+ = Number of entries in this chunk
+	# * +entries+ = Array of Hashes of [ResTypeConfig, ResTypeEntry] in this chunk
+	ResType = Struct.new(:header, :id, :config, :entry_count, :entries)
+	
+	##
+	# Structure that houses the configuration flags for a given resource.
+	# 
+	# ResTypeConfig = Struct.new(:imsi, :locale, :screen_type, :input, :screen_size, :version, :screen_config, :screen_size_dp)
+	#
+	# * +imsi+ = Flags marking country code and network code
+	# * +locale+ = Flags marking locale requirements (language)
+	# * +screen_type+ = Flags/values for screen density
+	# * +input+ = Flags marking input types and visibility status
+	# * +screen_size+ = Flags marking screen size and length
+	# * +version+ = Minimum API version
+	# * +screen_config+ = Flags marking screen configuration (like orientation)
+	# * +screen_size_dp+ = Flags marking smallest width constraints
+	#
+	# A default configuration is defined as ResTypeConfig.new(0, 0, 0, 0, 0, 0, 0, 0)
+	ResTypeConfig = Struct.new(:imsi, :locale, :screen_type, :input, :screen_size, :version, :screen_config, :screen_size_dp)
+
+	##
+	# Structure that houses the data for a given resource entry
+	#
+	# ResTypeEntry = Struct.new(:flags, :key, :data_type, :data)
+	#
+	# * +flags+ = Flags marking if the resource is complex or public
+	# * +key+ = Key string for the resource (e.g. "ic_launcher" of R.drawable.ic_launcher")
+	# * +data_type+ = Type identifier.  The meaning of this value varies with the type of resource
+	# * +data+ = Resource value (e.g. "res/drawable/ic_launcher" for R.drawable.ic_launcher")
+	#
+	# A single resource key can have multiple entries depending on configuration, so these structs
+	# are often returned in groups, keyed by a ResTypeConfig
+	ResTypeEntry = Struct.new(:flags, :key, :data_type, :data)
+
+	# PackageHeader containing information about all the type and key strings in the package
+	attr_reader :package_header
+	# StringPool containing all value strings in the package
+	attr_reader :stringpool_main
+	# StringPool containing all type strings in the package
+	attr_reader :stringpool_typestrings
+	# StringPool containing all key strings in the package
+	attr_reader :stringpool_keystrings
+	# Array of the ResTypeSpec chunks in the package
+	attr_reader :type_data
+
+	##
+	# Create a new ApkResources instance from the specified +apk_file+
+	#
+	# This opens and parses the contents of the APK's resources.arsc file.
+	
+	def initialize(apk_file)
+		data = nil		
+		# Get resources.arsc from the APK file
+		Zip::ZipFile.foreach(apk_file) do |f|
+		  if f.name.match(/resources.arsc/)
+			data = f.get_input_stream.read
+		  end
+		end
+		
+		# Parse the Table Chunk
+		## Header
+		header_type = read_short(data, HEADER_START)
+		header_size = read_short(data, HEADER_START+2)
+		header_chunk_size = read_word(data, HEADER_START+4)
+		header_package_count = read_word(data, HEADER_START+8)
+		puts "Resource Package Count = #{header_package_count}" if DEBUG
+		if header_package_count > 1
+			puts "ApkResources only supports single package resources."
+			exit(1)
+		end
+		
+		# Parse the StringPool Chunk
+		## Header
+		startoffset_pool = HEADER_START + header_size
+		puts "Parse Main StringPool Chunk" if DEBUG
+		@stringpool_main = parse_stringpool(data, startoffset_pool)
+		puts "#{@stringpool_main.values.length} strings found" if DEBUG
+		
+		# Parse the Package Chunk
+		## Header
+		startoffset_package = startoffset_pool + @stringpool_main.header.chunk_size
+		header = ChunkHeader.new( read_short(data, startoffset_package),
+				read_short(data, startoffset_package+2),
+				read_word(data, startoffset_package+4) )
+		
+		package_id = read_word(data, startoffset_package+8)
+		package_name = read_string(data, startoffset_package+12, 256, "UTF-8")
+		package_type_strings = read_word(data, startoffset_package+268)
+		package_last_type = read_word(data, startoffset_package+272)
+		package_key_strings = read_word(data, startoffset_package+276)
+		package_last_key = read_word(data, startoffset_package+280)
+		
+		@package_header = PackageHeader.new(header, package_id, package_name, package_type_strings, package_key_strings)
+		
+		## typeStrings StringPool
+		startoffset_typestrings = startoffset_package + package_type_strings
+		puts "Parse typeStrings StringPool Chunk" if DEBUG
+		@stringpool_typestrings = parse_stringpool(data, startoffset_typestrings)
+		
+		## keyStrings StringPool
+		startoffset_keystrings = startoffset_package + package_key_strings
+		puts "Parse keyStrings StringPool Chunk" if DEBUG
+		@stringpool_keystrings = parse_stringpool(data, startoffset_keystrings)
+		
+		## typeSpec/type Chunks		
+		@type_data = Array.new()
+		current_spec = nil
+		
+		current = startoffset_keystrings + @stringpool_keystrings.header.chunk_size
+		puts "Parse Type/TypeSpec Chunks" if DEBUG
+		while current < data.length
+			## Parse Header
+			header = ChunkHeader.new( read_short(data, current),
+					read_short(data, current+2),
+					read_word(data, current+4) )
+			## Check Type
+			if header.type == CHUNKTYPE_TYPESPEC
+				typespec_id = read_byte(data, current+8)
+				typespec_entrycount = read_word(data, current+12)
+				
+				## Parse the config flags for each entry
+				typespec_entries = Array.new()
+				i=0
+				while i < typespec_entrycount
+					offset = i * 4 + (current+16)
+					typespec_entries << read_word(data, offset)
+					
+					i += 1
+				end
+				
+				typespec_name = @stringpool_typestrings.values[typespec_id - 1]
+				current_spec = ResTypeSpec.new(header, typespec_name, typespec_entrycount, typespec_entries, nil)
+				
+				@type_data << current_spec
+				current += header.chunk_size
+			elsif header.type == CHUNKTYPE_TYPE
+				type_id = read_byte(data, current+8)
+				type_entrycount = read_word(data, current+12) 
+				type_entryoffset = read_word(data, current+16)
+
+				## The config flags set for this type chunk
+				## TODO: Vary the size of the config structure based on size to accomodate for new flags
+				config_size = read_word(data, current+20) # Number of bytes in structure
+				type_config = ResTypeConfig.new( read_word(data, current+24),
+						read_word(data, current+28),
+						read_word(data, current+32),
+						read_word(data, current+36 ),
+						read_word(data, current+40),
+						read_word(data, current+44),
+						read_word(data, current+48),
+						read_word(data, current+52) )
+
+				## The remainder of the chunk is a list of the entry values for that type/configuration
+				type_name = @stringpool_typestrings.values[type_id - 1]				
+				if current_spec.types == nil
+					current_spec.types = ResType.new(header, type_name, type_config, type_entrycount, Array.new())
+				end
+
+				i=0
+				while i < type_entrycount
+					## Ensure a hash exists for each type
+					if current_spec.types.entries[i] == nil
+						current_spec.types.entries[i] = Hash.new()
+					end
+					current_entry = current_spec.types.entries[i]
+
+					## Get the start of the type from the offsets table
+					index_offset = i * 4 + (current+56)
+					start_offset = read_word(data, index_offset)
+					if start_offset != OFFSET_NO_ENTRY
+						## Set the index_offset to the start of the current entry
+						index_offset = current + type_entryoffset + start_offset
+	
+						entry_flags = read_short(data, index_offset+2)
+						entry_key = read_word(data, index_offset+4)
+						entry_data_type = read_byte(data, index_offset+11)
+						entry_data = read_word(data, index_offset+12)
+						
+						# Find the key in our strings index
+						key_name = @stringpool_keystrings.values[entry_key]
+						# Parse the value into a string
+						data_value = nil
+						case type_name
+							when TYPE_STRING, TYPE_DRAWABLE
+								data_value = get_resource_string(entry_data_type, entry_data)
+							when TYPE_COLOR
+								data_value = get_resource_color(entry_data_type, entry_data)
+							when TYPE_DIMENSION
+								data_value = get_resource_dimension(entry_data_type, entry_data)
+							when TYPE_INTEGER
+								data_value = get_resource_integer(entry_data_type, entry_data)
+							when TYPE_BOOLEAN
+								data_value = get_resource_bool(entry_data_type, entry_data)
+							else
+								puts "Complex Resources not yet supported." if DEBUG
+								data_value = entry_data.to_s
+						end
+						current_entry[type_config] = ResTypeEntry.new(entry_flags, key_name, entry_data_type, data_value)
+					end
+					i += 1
+				end
+				
+				current += header.chunk_size
+			else
+				puts "Unknown Chunk Found: #{header.type} #{header.size}" if DEBUG
+				## End Immediately
+				current = data.length
+			end
+		end
+		
+	end #initalize
+	
+	##
+	# Return array of all string values in the file
+	
+	def get_all_strings
+		return @stringpool_main.values
+	end
+	
+	##
+	# Return array of all the type values in the file
+	
+	def get_all_types
+		return @stringpool_typestrings.values
+	end
+	
+	##
+	# Return array of all the key values in the file
+	
+	def get_all_keys
+		return @stringpool_keystrings.values
+	end
+
+	##
+	# Obtain the key value for a given resource id
+	#
+	# res_id: ID value of a resource as a FixNum or String representation (i.e. 0x7F060001)
+	# xml_format: Optionally format return string for XML files.
+	#
+	# If xml_format is true, return value will be @<type>/<key>
+	# If xml_format is false or missing, return value will be R.<type>.<key>
+	
+	def get_resource_key(res_id, xml_format=false)
+		if res_id.is_a? String
+			res_id = res_id.hex
+		end
+		
+		# R.id integers are a concatenation of package_id, type_id, and entry index
+		res_package = (res_id >> 24) & 0xFF
+		res_type = (res_id >> 16) & 0xFF
+		res_index = res_id & 0xFFFF
+
+		if res_package != @package_header.id
+			# This is not a resource we can parse
+			return res_id_to_s(res_id)
+		end
+		
+		res_spec = @type_data[res_type-1]
+		entry = res_spec.types.entries[res_index]
+		
+		if entry == nil
+			# There is no entry in our table for this resource
+			return res_id_to_s(res_id)
+		end
+		
+		if xml_format
+			return "@#{res_spec.id}/#{entry.values[0].key}"
+		else
+			return "R.#{res_spec.id}.#{entry.values[0].key}"
+		end
+	end
+
+	##
+	# Obtain the default value for a given resource id
+	#
+	# res_id: ID values of a resources as a FixNum or String representation (i.e. 0x7F060001)
+	#
+	# Returns: The default ResTypeEntry to the given id, or nil if no default exists
+	
+	def get_default_resource_value(res_id)
+		entries = get_resource_value(res_id)
+		default = ResTypeConfig.new(0, 0, 0, 0, 0, 0, 0, 0)
+		
+		return entries[default]
+	end
+
+	##
+	# Obtain the value(s) for a given resource id.
+	# A default resource is one defined in an unqualified directory.
+	#
+	# res_id: ID value of a resource as a FixNum or String representation (i.e. 0x7F060001)
+	#
+	# Returns: Hash of all entries matching this id, keyed by their matching ResTypeConfig
+	
+	def get_resource_value(res_id)
+		if res_id.is_a? String
+			res_id = res_id.hex
+		end
+		
+		# R.id integers are a concatenation of package_id, type_id, and entry index
+		res_package = (res_id >> 24) & 0xFF
+		res_type = (res_id >> 16) & 0xFF
+		res_index = res_id & 0xFFFF
+
+		if res_package != @package_header.id
+			# This is not a resource we can parse
+			return res_id_to_s(res_id)
+		end
+		
+		res_spec = @type_data[res_type-1]
+		
+		entries = res_spec.types.entries[res_index]
+		if entries == nil
+			puts "Could not find #{type_name} ResType chunk" if DEBUG
+			return res_id_to_s(res_id)
+		end
+		
+		return entries
+	end
+
+	private # Private Helper Methods
+
+	# Type Constants
+	TYPE_ARRAY = "array" # :nodoc:
+	TYPE_ATTRIBUTE = "attr" # :nodoc:
+	TYPE_BOOLEAN = "bool" # :nodoc:
+	TYPE_COLOR = "color" # :nodoc:
+	TYPE_DIMENSION = "dimen" # :nodoc:
+	TYPE_DRAWABLE = "drawable" # :nodoc:
+	TYPE_FRACTION = "fraction" # :nodoc:
+	TYPE_INTEGER = "integer" # :nodoc:
+	TYPE_LAYOUT = "layout" # :nodoc:
+	TYPE_PLURALS = "plurals" # :nodoc:
+	TYPE_STRING = "string" # :nodoc:
+	TYPE_STYLE = "style" # :nodoc:
+	
+	# Data Type Constants
+	TYPE_INT_DEC = 0x10 # :nodoc:
+	TYPE_INT_HEX = 0x11 # :nodoc:
+	TYPE_BOOL = 0x12 # :nodoc:
+	TYPE_INT_COLOR_RGB4 = 0x1F # :nodoc:
+	TYPE_INT_COLOR_ARGB4 = 0x1E # :nodoc:
+	TYPE_INT_COLOR_RGB8 = 0x1D # :nodoc:
+	TYPE_INT_COLOR_ARGB8 = 0x1C # :nodoc:
+	COMPLEX_UNIT_PX = 0x0 # :nodoc:
+	COMPLEX_UNIT_DIP = 0x1 # :nodoc:
+	COMPLEX_UNIT_SP = 0x2 # :nodoc:
+	COMPLEX_UNIT_PT = 0x3 # :nodoc:
+	COMPLEX_UNIT_IN = 0x4 # :nodoc:
+	COMPLEX_UNIT_MM = 0x5 # :nodoc:
+	
+	# Data Constants
+	TYPE_BOOL_TRUE = 0xFFFFFFFF # :nodoc:
+	TYPE_BOOL_FALSE = 0x00000000 # :nodoc:
+	
+	# Header Constants
+	CHUNKTYPE_TYPESPEC = 0x202 # :nodoc:
+	CHUNKTYPE_TYPE = 0x201 # :nodoc:
+	
+	#Flag Constants
+	FLAG_UTF8 = 0x100 # :nodoc:
+	
+	OFFSET_NO_ENTRY = 0xFFFFFFFF # :nodoc:
+	HEADER_START = 0 # :nodoc:
+
+	# Read a 32-bit word from a specific location in the data
+	def read_word(data, offset)
+	  out = data[offset,4].unpack('V').first rescue 0
+	  return out
+	end
+	
+	# Read a 16-bit short from a specific location in the data
+	def read_short(data, offset)
+	  out = data[offset,2].unpack('v').first rescue 0
+	  return out
+	end
+		
+	# Read a 8-bit byte from a specific location in the data
+	def read_byte(data, offset)
+	  out = data[offset,1].unpack('C').first rescue 0
+	  return out
+	end
+
+	# Read in length bytes in as a String
+	def read_string(data, offset, length, encoding)
+		if "UTF-16".casecmp(encoding) == 0
+			out = data[offset, length].unpack('v*').pack('U*')
+		else
+			out = data[offset, length].unpack('C*').pack('U*')
+		end
+	  return out
+	end
+	
+	# Return id as a hex string
+	def res_id_to_s(res_id)
+		return "0x#{res_id.to_s(16)}"
+	end
+	
+	# Parse out a StringPool chunk
+	def parse_stringpool(data, offset)
+		pool_header = ChunkHeader.new( read_short(data, offset),
+				read_short(data, offset+2),
+				read_word(data, offset+4) )
+	
+		pool_string_count = read_word(data, offset+8)
+		pool_style_count = read_word(data, offset+12)
+		pool_flags = read_word(data, offset+16)
+		format_utf8 = (pool_flags & FLAG_UTF8) != 0
+		puts 'StringPool format is %s' % [format_utf8 ? "UTF-8" : "UTF-16"] if DEBUG
+
+		pool_string_offset = read_word(data, offset+20)
+		pool_style_offset = read_word(data, offset+24)
+		
+		values = Array.new()
+		i = 0
+		while i < pool_string_count
+			# Read the string value
+			index = i * 4 + (offset+28)
+			offset_addr = pool_string_offset + offset + read_word(data, index)
+			if format_utf8
+				length = read_byte(data, offset_addr)
+				if (length & 0x80) != 0
+					length = ((length & 0x7F) << 8) + read_byte(data, offset_addr+1)
+				end
+				
+				values << read_string(data, offset_addr + 2, length, "UTF-8")
+			else
+				length = read_short(data, offset_addr)
+				if (length & 0x8000) != 0
+					#There is one more length value before the data
+					length = ((length & 0x7FFF) << 16) + read_short(data, offset_addr+2)
+					values << read_string(data, offset_addr + 4, length * 2, "UTF-16")
+				else
+					# Read the data
+					values << read_string(data, offset_addr + 2, length * 2, "UTF-16")
+				end
+			end	
+		
+			i += 1
+		end
+		
+		return StringPool.new(pool_header, pool_string_count, pool_style_count, values)
+	end
+
+	# Obtain string value for resource id
+	def get_resource_string(entry_datatype, entry_data)
+		result = @stringpool_main.values[entry_data]
+		return result
+	end
+	
+	# Obtain boolean value for resource id
+	def get_resource_bool(entry_datatype, entry_data)
+		if entry_data == TYPE_BOOL_TRUE
+			return "true"
+		elsif entry_data == TYPE_BOOL_FALSE
+			return "false"
+		else
+			return "undefined"
+		end	
+	end
+	
+	# Obtain integer value for resource id
+	def get_resource_integer(entry_datatype, entry_data)
+		if entry_datatype == TYPE_INT_HEX
+			return "0x#{entry_data.to_s(16)}"
+		else
+			return entry_data.to_s
+		end
+	end
+
+	# Obtain color value for resource id
+	def get_resource_color(entry_datatype, entry_data)
+		case entry_datatype
+		when TYPE_INT_COLOR_RGB4
+			return "#" + ((entry_data >> 16) & 0xF).to_s(16) + ((entry_data >> 8) & 0xF).to_s(16) + (entry_data & 0xF).to_s(16)
+		when TYPE_INT_COLOR_ARGB4
+			return "#" + ((entry_data >> 24) & 0xF).to_s(16) + ((entry_data >> 16) & 0xF).to_s(16) + ((entry_data >> 8) & 0xF).to_s(16) + (entry_data & 0xF).to_s(16)
+		when TYPE_INT_COLOR_RGB8
+			return "#" + ((entry_data >> 16) & 0xFF).to_s(16) + ((entry_data >> 8) & 0xFF).to_s(16) + (entry_data & 0xFF).to_s(16)
+		when TYPE_INT_COLOR_ARGB8
+			return "#" + ((entry_data >> 24) & 0xFF).to_s(16) + ((entry_data >> 16) & 0xFF).to_s(16) + ((entry_data >> 8) & 0xFF).to_s(16) + (entry_data & 0xFF).to_s(16)
+		else
+			return "0x#{entry_data.to_s(16)}"
+		end
+	end
+	
+	# Obtain dimension value for resource id
+	def get_resource_dimension(entry_datatype, entry_data)
+		unit_type = (entry_data & 0xFF)
+		case unit_type
+		when COMPLEX_UNIT_PX
+			unit_name = "px"
+		when COMPLEX_UNIT_DIP
+			unit_name = "dp"
+		when COMPLEX_UNIT_SP
+			unit_name = "sp"
+		when COMPLEX_UNIT_PT
+			unit_name = "pt"
+		when COMPLEX_UNIT_IN
+			unit_name = "in"
+		when COMPLEX_UNIT_MM
+			unit_name = "mm"
+		else
+			unit_name = ""
+		end
+		
+		return ((entry_data >> 8) & 0xFFFFFF).to_s + unit_name
+	end	
+end

data/lib/apktools/apkxml.rb

@@ -0,0 +1,424 @@
+# Copyright (C) 2012 Dave Smith
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this
+# software and associated documentation files (the "Software"), to deal in the Software
+# without restriction, including without limitation the rights to use, copy, modify,
+# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies
+# or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require 'zip/zip'
+require 'apktools/apkresources'
+
+##
+# Class to parse an APK's binary XML format back into textual XML
+class ApkXml
+	
+	DEBUG = false # :nodoc:
+	
+	##
+	# Structure defining the type and size of each resource chunk
+	#
+	# ChunkHeader = Struct.new(:type, :size, :chunk_size)
+	ChunkHeader = Struct.new(:type, :size, :chunk_size)
+	
+	##
+	# Structure that houses a group of strings
+	#
+	# StringPool = Struct.new(:header, :string_count, :style_count, :values)
+	#
+	# * +header+ = ChunkHeader
+	# * +string_count+ = Number of normal strings in the pool
+	# * +style_count+ = Number of styled strings in the pool
+	# * +values+ = Array of the string values
+	StringPool = Struct.new(:header, :string_count, :style_count, :values)
+	
+	##
+	# Structure to house mappings of resource ids to strings
+	#
+	# XmlResourceMap = Struct.new(:header, :ids, :strings)
+	#
+	# * +header+ = ChunkHeader
+	# * +ids+ = Array of resource ids
+	# * +strings+ = Matching Array of resource strings
+	XmlResourceMap = Struct.new(:header, :ids, :strings)
+	
+	##
+	# Structure defining header of an XML node
+	#
+	# XmlTreeHeader = Struct.new(:header, :line_num, :comment)
+	#
+	# * +header+ = ChunkHeader
+	# * +line_num+ = Line number in original file
+	# * +comment+ = Optional comment
+	XmlTreeHeader = Struct.new(:header, :line_num, :comment)
+	
+	##
+	# Structure defining an XML element
+	#
+	# XmlElement = Struct.new(:header, :namespace, :name, :id_idx, :class_idx, :style_idx, :attributes, :is_root)
+	#
+	# * +header+ = XmlTreeHeader
+	# * +namespace+ = Namespace prefix of the element
+	# * +name+ = Name of the element
+	# * +id_idx+ = Index of the attribute that represents the "id" in this element, if any
+	# * +class_idx+ = Index of the attribute that represents the "class" in this element, if any
+	# * +style_idx+ = Index of the attribute that represents the "style" in this element, if any
+	# * +attributes+ = Array of XmlAttribute elements
+	# * +is_root+ = Marks if this is the root element
+	XmlElement = Struct.new(:header, :namespace, :name, :id_idx, :class_idx, :style_idx, :attributes, :is_root)
+	
+	##
+	# Structure defining an XML element's attribute
+	#
+	# XmlAttribute = Struct.new(:namespace, :name, :raw, :value)
+	#
+	# * +namespace+ = Namespace prefix of the attribute
+	# * +name+ = Name of the attribute
+	# * +raw+ = Original raw string value of the attribute, if one exists
+	# * +value+ = ResTypeEntry for the typed value of the attribute, if one exists
+	XmlAttribute = Struct.new(:namespace, :name, :raw, :value)
+	
+	##
+	# Structure that houses the data for a given resource entry
+	#
+	# ResTypeEntry = Struct.new(:flags, :key, :data_type, :data)
+	#
+	# * +flags+ = Flags marking if the resource is complex or public
+	# * +key+ = Key string for the resource (e.g. "ic_launcher" of R.drawable.ic_launcher")
+	# * +data_type+ = Type identifier.  The meaning of this value varies with the type of resource
+	# * +data+ = Resource value (e.g. "res/drawable/ic_launcher" for R.drawable.ic_launcher")
+	#
+	# A single resource key can have multiple entries depending on configuration, so these structs
+	# are often returned in groups, keyed by a ResTypeConfig
+	ResTypeEntry = Struct.new(:flags, :key, :data_type, :data)
+	
+	# APK file where parser will search for XML
+	attr_reader :current_apk
+	# ApkResources instance used to resolve resources in this APK
+	attr_reader :apk_resources
+	
+	##
+	# Create a new ApkXml instance from the specified +apk_file+
+	#
+	# This opens and parses the contents of the APK's resources.arsc file.
+	def initialize(apk_file)
+		@current_apk = apk_file
+		@apk_resources = ApkResources.new(apk_file)
+	end #initialize
+	
+	##
+	# Read the requested XML file from inside the APK and parse out into
+	# readable textual XML.  Returns a string of the parsed XML.
+	#
+	# xml_file: ID value of a resource as a FixNum or String representation (i.e. 0x7F060001)
+	# pretty: Optionally format the XML output as human readable
+	# resolve_resources: Optionally, where possible, resolve resource references to their default value
+	#
+	# This opens and parses the contents of the APK's resources.arsc file.
+	def parse_xml(xml_file, pretty = false, resolve_resources = false)
+		xml_output = ""
+		indent = 0
+		data = nil		
+		
+		# Get the XML from the APK file
+		Zip::ZipFile.foreach(@current_apk) do |f|
+		  if f.name.match(xml_file)
+			data = f.get_input_stream.read
+		  end
+		end
+		
+		# Parse the Header Chunk		
+		header = ChunkHeader.new( read_short(data, HEADER_START),
+				read_short(data, HEADER_START+2),
+				read_word(data, HEADER_START+4) )
+		
+		# Parse the StringPool Chunk
+		startoffset_pool = HEADER_START + header.size
+		puts "Parse Main StringPool Chunk" if DEBUG
+		stringpool_main = parse_stringpool(data, startoffset_pool)
+		puts "#{stringpool_main.values.length} strings found" if DEBUG
+		
+		# Parse the remainder of the file chunks based on type
+		namespaces = Hash.new()
+		current = startoffset_pool + stringpool_main.header.chunk_size
+		puts "Parse Remaining Chunks" if DEBUG
+		while current < data.length
+			## Parse Header
+			header = ChunkHeader.new( read_short(data, current),
+					read_short(data, current+2),
+					read_word(data, current+4) )
+			## Check Type
+			if header.type == TYPE_XML_RESOURCEMAP
+				## Maps resource ids to strings in the pool
+				map_ids = Array.new()
+				map_strings = Array.new()
+								
+				index_offset = current + header.size
+				i = 0
+				while index_offset < (current + header.chunk_size)
+					map_ids << read_word(data, index_offset)
+					map_strings << stringpool_main.values[i]
+					
+					i += 1
+					index_offset = i * 4 + (current + header.size)
+				end
+				
+				current += header.chunk_size
+			elsif header.type == TYPE_XML_STARTNAMESPACE
+				tree_header = parse_tree_header(header, data, current)
+				body_start = current+header.size
+				prefix = stringpool_main.values[read_word(data, body_start)]
+				uri = stringpool_main.values[read_word(data, body_start+4)]
+				namespaces[uri] = prefix
+				puts "NAMESPACE_START: xmlns:#{prefix} = '#{uri}'" if DEBUG
+				current += header.chunk_size
+			elsif header.type == TYPE_XML_ENDNAMESPACE
+				tree_header = parse_tree_header(header, data, current)
+				body_start = current+header.size
+				prefix = stringpool_main.values[read_word(data, body_start)]
+				uri = stringpool_main.values[read_word(data, body_start+4)]
+				puts "NAMESPACE_END: xmlns:#{prefix} = '#{uri}'" if DEBUG
+				current += header.chunk_size
+			elsif header.type == TYPE_XML_STARTELEMENT
+				tree_header = parse_tree_header(header, data, current)
+				body_start = current+header.size
+				namespace = nil
+				if read_word(data, body_start) != OFFSET_NO_ENTRY
+					namespace = stringpool_main.values[read_word(data, body_start)]
+				end
+				name = stringpool_main.values[read_word(data, body_start+4)]
+				
+				attribute_offset = read_short(data, body_start+8)
+				attribute_size = read_short(data, body_start+10)
+				attribute_count = read_short(data, body_start+12)
+				id_idx = read_short(data, body_start+14)
+				class_idx = read_short(data, body_start+16)
+				style_idx = read_short(data, body_start+18)
+				
+				attributes = Array.new()
+				i=0
+				while i < attribute_count
+					index_offset = i * attribute_size + (body_start + attribute_offset)
+					attr_namespace = nil
+					if read_word(data, index_offset) != OFFSET_NO_ENTRY
+						attr_uri = stringpool_main.values[read_word(data, index_offset)]
+						attr_namespace = namespaces[attr_uri]
+					end
+					attr_name = stringpool_main.values[read_word(data, index_offset+4)]
+					attr_raw = nil
+					if read_word(data, index_offset+8) != OFFSET_NO_ENTRY
+						attr_raw = stringpool_main.values[read_word(data, index_offset+8)]
+					end					
+					entry = ResTypeEntry.new(0, nil, read_byte(data, index_offset+15), read_word(data, index_offset+16))
+					
+					attributes << XmlAttribute.new(attr_namespace, attr_name, attr_raw, entry)
+					i += 1
+				end
+				
+				element = XmlElement.new(tree_header, namespace, name, id_idx, class_idx, style_idx, attributes, xml_output == "")
+				
+				puts "ELEMENT_START: #{element.namespace} #{element.name}" if DEBUG
+				display_name = element.namespace == nil ? element.name : "#{element.namespace}:#{element.name}"
+
+				if pretty
+					xml_output += "\n" + ("  " * indent)
+					indent += 1
+				end
+				xml_output += "<#{display_name} "
+				# Only print namespaces on the root element
+				if element.is_root
+					keys = namespaces.keys
+					keys.each do |key|
+						xml_output += "xmlns:#{namespaces[key]}=\"#{key}\" "
+						if pretty && key != keys.last
+							xml_output += "\n" + ("  " * indent)
+						end
+					end
+				end
+
+				element.attributes.each do |attr|
+					puts "---ATTRIBUTE: #{attr.namespace} #{attr.name} #{attr.raw} => #{attr.value.data_type} #{attr.value.data.to_s(16)}" if DEBUG
+					display_name = attr.namespace == nil ? attr.name : "#{attr.namespace}:#{attr.name}"
+					display_value = nil
+					if attr.raw != nil # Use raw value
+						display_value = attr.raw
+					elsif attr.value.data_type == 1
+						# Find the resource
+						default_res = apk_resources.get_default_resource_value(attr.value.data)
+						if resolve_resources && default_res != nil
+							display_value = default_res.data
+						else
+							display_value = apk_resources.get_resource_key(attr.value.data, true)
+						end
+					else # Value is a constant
+						display_value = "0x#{attr.value.data.to_s(16)}"
+					end
+					
+					if pretty
+						xml_output += "\n" + ("  " * indent)
+					end					
+					xml_output += "#{display_name}=\"#{display_value}\" "
+				end
+				
+				xml_output += ">"
+					
+				current += header.chunk_size
+			elsif header.type == TYPE_XML_ENDELEMENT
+				tree_header = parse_tree_header(header, data, current)
+				body_start = current+header.size
+				namespace = nil
+				if read_word(data, body_start) != OFFSET_NO_ENTRY
+					namespace = stringpool_main.values[read_word(data, body_start)]
+				end
+				name = stringpool_main.values[read_word(data, body_start+4)]
+				
+				puts "ELEMENT END: #{namespace} #{name}" if DEBUG
+				display_name = namespace == nil ? name : "#{namespace}:#{name}"
+				if pretty
+					indent -= 1
+					if indent < 0
+						indent = 0
+					end
+					xml_output += "\n" + ("  " * indent)
+				end
+				xml_output += "</#{display_name}>"
+
+				
+				current += header.chunk_size
+			elsif header.type == TYPE_XML_CDATA
+				tree_header = parse_tree_header(header, data, current)
+				body_start = current+header.size
+	
+				cdata = stringpool_main.values[read_word(data, body_start)]
+				cdata_type = read_word(data, body_start+7)
+				cdata_value = read_word(data, body_start+8)
+				puts "CDATA: #{cdata} #{cdata_type} #{cdata_value}" if DEBUG
+				
+				cdata.split(/\r?\n/).each do |item|
+					if pretty
+						xml_output += "\n" + ("  " * indent)
+					end	
+					xml_output += "<![CDATA[#{item.strip}]]>"
+				end
+				
+				current += header.chunk_size
+			else
+				puts "Unknown Chunk Found: #{header.type} #{header.size}" if DEBUG
+				## End Immediately
+				current = data.length
+			end
+		end
+		
+		return xml_output
+	end #parse_xml
+	
+	private # Private Helper Methods
+
+	#Flag Constants
+	FLAG_UTF8 = 0x100 # :nodoc:
+	
+	OFFSET_NO_ENTRY = 0xFFFFFFFF # :nodoc:
+	HEADER_START = 0 # :nodoc:
+	
+	TYPE_XML_RESOURCEMAP = 0x180 # :nodoc:
+	TYPE_XML_STARTNAMESPACE = 0x100 # :nodoc:
+	TYPE_XML_ENDNAMESPACE = 0x101 # :nodoc:
+	TYPE_XML_STARTELEMENT = 0x102 # :nodoc:
+	TYPE_XML_ENDELEMENT = 0x103 # :nodoc:
+	TYPE_XML_CDATA = 0x104 # :nodoc:
+	
+	# Read a 32-bit word from a specific location in the data
+	def read_word(data, offset)
+	  out = data[offset,4].unpack('V').first rescue 0
+	  return out
+	end
+	
+	# Read a 16-bit short from a specific location in the data
+	def read_short(data, offset)
+	  out = data[offset,2].unpack('v').first rescue 0
+	  return out
+	end
+		
+	# Read a 8-bit byte from a specific location in the data
+	def read_byte(data, offset)
+	  out = data[offset,1].unpack('C').first rescue 0
+	  return out
+	end
+
+	# Read in length bytes in as a String
+	def read_string(data, offset, length, encoding)
+		if "UTF-16".casecmp(encoding) == 0
+			out = data[offset, length].unpack('v*').pack('U*')
+		else
+			out = data[offset, length].unpack('C*').pack('U*')
+		end
+	  return out
+	end
+	
+	# Parse out an XmlTreeHeader
+	def parse_tree_header(chunk_header, data, offset)
+		line_num = read_word(data, offset+8)
+		comment = nil
+		if read_word(data, offset+12) != OFFSET_NO_ENTRY
+			comment = stringpool_main.values[read_word(data, offset+12)]
+		end
+		return XmlTreeHeader.new(chunk_header, line_num, comment)
+	end
+	
+	# Parse out a StringPool chunk
+	def parse_stringpool(data, offset)
+		pool_header = ChunkHeader.new( read_short(data, offset),
+				read_short(data, offset+2),
+				read_word(data, offset+4) )
+	
+		pool_string_count = read_word(data, offset+8)
+		pool_style_count = read_word(data, offset+12)
+		pool_flags = read_word(data, offset+16)
+		format_utf8 = (pool_flags & FLAG_UTF8) != 0
+		puts 'StringPool format is %s' % [format_utf8 ? "UTF-8" : "UTF-16"] if DEBUG
+
+		pool_string_offset = read_word(data, offset+20)
+		pool_style_offset = read_word(data, offset+24)
+		
+		values = Array.new()
+		i = 0
+		while i < pool_string_count
+			# Read the string value
+			index = i * 4 + (offset+28)
+			offset_addr = pool_string_offset + offset + read_word(data, index)
+			if format_utf8
+				length = read_byte(data, offset_addr)
+				if (length & 0x80) != 0
+					length = ((length & 0x7F) << 8) + read_byte(data, offset_addr+1)
+				end
+				
+				values << read_string(data, offset_addr + 2, length, "UTF-8")
+			else
+				length = read_short(data, offset_addr)
+				if (length & 0x8000) != 0
+					#There is one more length value before the data
+					length = ((length & 0x7FFF) << 16) + read_short(data, offset_addr+2)
+					values << read_string(data, offset_addr + 4, length * 2, "UTF-16")
+				else
+					# Read the data
+					values << read_string(data, offset_addr + 2, length * 2, "UTF-16")
+				end
+			end	
+		
+			i += 1
+		end
+		
+		return StringPool.new(pool_header, pool_string_count, pool_style_count, values)
+	end
+	
+end

data/lib/apktools/resconfiguration.rb

@@ -0,0 +1,102 @@
+# Copyright (C) 2012 Dave Smith
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this
+# software and associated documentation files (the "Software"), to deal in the Software
+# without restriction, including without limitation the rights to use, copy, modify,
+# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies
+# or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+##
+# Constants for configuration flags
+module ResConfiguration
+
+	ACONFIGURATION_ORIENTATION_ANY  = 0x0000
+	ACONFIGURATION_ORIENTATION_PORT = 0x0001
+	ACONFIGURATION_ORIENTATION_LAND = 0x0002
+	ACONFIGURATION_ORIENTATION_SQUARE = 0x0003
+
+	ACONFIGURATION_TOUCHSCREEN_ANY  = 0x0000
+	ACONFIGURATION_TOUCHSCREEN_NOTOUCH  = 0x0001
+	ACONFIGURATION_TOUCHSCREEN_STYLUS  = 0x0002
+	ACONFIGURATION_TOUCHSCREEN_FINGER  = 0x0003
+
+	ACONFIGURATION_DENSITY_DEFAULT = 0
+	ACONFIGURATION_DENSITY_LOW = 120
+	ACONFIGURATION_DENSITY_MEDIUM = 160
+	ACONFIGURATION_DENSITY_TV = 213
+	ACONFIGURATION_DENSITY_HIGH = 240
+	ACONFIGURATION_DENSITY_XHIGH = 320
+	ACONFIGURATION_DENSITY_XXHIGH = 480
+	ACONFIGURATION_DENSITY_NONE = 0xffff
+
+	ACONFIGURATION_KEYBOARD_ANY  = 0x0000
+	ACONFIGURATION_KEYBOARD_NOKEYS  = 0x0001
+	ACONFIGURATION_KEYBOARD_QWERTY  = 0x0002
+	ACONFIGURATION_KEYBOARD_12KEY  = 0x0003
+
+	ACONFIGURATION_NAVIGATION_ANY  = 0x0000
+	ACONFIGURATION_NAVIGATION_NONAV  = 0x0001
+	ACONFIGURATION_NAVIGATION_DPAD  = 0x0002
+	ACONFIGURATION_NAVIGATION_TRACKBALL  = 0x0003
+	ACONFIGURATION_NAVIGATION_WHEEL  = 0x0004
+
+	ACONFIGURATION_KEYSHIDDEN_ANY = 0x0000
+	ACONFIGURATION_KEYSHIDDEN_NO = 0x0001
+	ACONFIGURATION_KEYSHIDDEN_YES = 0x0002
+	ACONFIGURATION_KEYSHIDDEN_SOFT = 0x0003
+
+	ACONFIGURATION_NAVHIDDEN_ANY = 0x0000
+	ACONFIGURATION_NAVHIDDEN_NO = 0x0001
+	ACONFIGURATION_NAVHIDDEN_YES = 0x0002
+
+	ACONFIGURATION_SCREENSIZE_ANY  = 0x00
+	ACONFIGURATION_SCREENSIZE_SMALL = 0x01
+	ACONFIGURATION_SCREENSIZE_NORMAL = 0x02
+	ACONFIGURATION_SCREENSIZE_LARGE = 0x03
+	ACONFIGURATION_SCREENSIZE_XLARGE = 0x04
+
+	ACONFIGURATION_SCREENLONG_ANY = 0x00
+	ACONFIGURATION_SCREENLONG_NO = 0x1
+	ACONFIGURATION_SCREENLONG_YES = 0x2
+
+	ACONFIGURATION_UI_MODE_TYPE_ANY = 0x00
+	ACONFIGURATION_UI_MODE_TYPE_NORMAL = 0x01
+	ACONFIGURATION_UI_MODE_TYPE_DESK = 0x02
+	ACONFIGURATION_UI_MODE_TYPE_CAR = 0x03
+	ACONFIGURATION_UI_MODE_TYPE_TELEVISION = 0x04
+	ACONFIGURATION_UI_MODE_TYPE_APPLIANCE = 0x05
+	
+	ACONFIGURATION_UI_MODE_NIGHT_ANY = 0x00
+	ACONFIGURATION_UI_MODE_NIGHT_NO = 0x1
+	ACONFIGURATION_UI_MODE_NIGHT_YES = 0x2
+
+	ACONFIGURATION_SCREEN_WIDTH_DP_ANY = 0x0000
+	ACONFIGURATION_SCREEN_HEIGHT_DP_ANY = 0x0000
+	ACONFIGURATION_SMALLEST_SCREEN_WIDTH_DP_ANY = 0x0000
+	
+	ACONFIGURATION_MCC = 0x0001
+	ACONFIGURATION_MNC = 0x0002
+	ACONFIGURATION_LOCALE = 0x0004
+	ACONFIGURATION_TOUCHSCREEN = 0x0008
+	ACONFIGURATION_KEYBOARD = 0x0010
+	ACONFIGURATION_KEYBOARD_HIDDEN = 0x0020
+	ACONFIGURATION_NAVIGATION = 0x0040
+	ACONFIGURATION_ORIENTATION = 0x0080
+	ACONFIGURATION_DENSITY = 0x0100
+	ACONFIGURATION_SCREEN_SIZE = 0x0200
+	ACONFIGURATION_VERSION = 0x0400
+	ACONFIGURATION_SCREEN_LAYOUT = 0x0800
+	ACONFIGURATION_UI_MODE = 0x1000
+	ACONFIGURATION_SMALLEST_SCREEN_SIZE = 0x2000
+
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: apktools
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Dave Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library to assist reading resource data out of Android APKs
+email: dave@xcellentcreations.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/apktools/apkresources.rb
+- lib/apktools/apkxml.rb
+- lib/apktools/resconfiguration.rb
+homepage: http://github.com/devunwired/apktools
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.22
+signing_key: 
+specification_version: 3
+summary: APKTools
+test_files: []