Class: ApkXml

Inherits:

Object

• Object
• ApkXml

Defined in:

lib/apktools/apkxml.rb

Overview

Class to parse an APK’s binary XML format back into textual XML

Defined Under Namespace

Classes: ChunkHeader, ResTypeEntry, StringPool, XmlAttribute, XmlElement, XmlResourceMap, XmlTreeHeader

Constant Summary

DEBUG =

:nodoc:

false

Instance Attribute Summary

• #apk_resources ⇒ Object readonly

  ApkResources instance used to resolve resources in this APK.

• #current_apk ⇒ Object readonly

  APK file where parser will search for XML.

• #xml_elements ⇒ Object readonly

  Array of XmlElements from the last parse operation.

Instance Method Summary

• #initialize(apk_file) ⇒ ApkXml constructor

  Create a new ApkXml instance from the specified apk_file.

• #parse_xml(xml_file, pretty = false, resolve_resources = false) ⇒ Object

  Read the requested XML file from inside the APK and parse out into readable textual XML.

Constructor Details

#initialize(apk_file) ⇒ ApkXml

Create a new ApkXml instance from the specified apk_file

This opens and parses the contents of the APK’s resources.arsc file.

# File 'lib/apktools/apkxml.rb', line 115

def initialize(apk_file)
	@current_apk = apk_file
	@apk_resources = ApkResources.new(apk_file)
end

Instance Attribute Details

#apk_resources ⇒ Object (readonly)

ApkResources instance used to resolve resources in this APK

# File 'lib/apktools/apkxml.rb', line 107

def apk_resources
  @apk_resources
end

#current_apk ⇒ Object (readonly)

APK file where parser will search for XML

# File 'lib/apktools/apkxml.rb', line 105

def current_apk
  @current_apk
end

#xml_elements ⇒ Object (readonly)

Array of XmlElements from the last parse operation

# File 'lib/apktools/apkxml.rb', line 109

def xml_elements
  @xml_elements
end

Instance Method Details

#parse_xml(xml_file, pretty = false, resolve_resources = false) ⇒ Object

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.

# File 'lib/apktools/apkxml.rb', line 129

def parse_xml(xml_file, pretty = false, resolve_resources = false)
	# Reset variables
	@xml_elements = Array.new()
	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
			# Parse the element/attribute data
			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
					# Attribute has a raw value, use it
					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))
				
				attr_value = nil
				if attr_raw != nil # Use raw value
					attr_value = attr_raw
				elsif entry.data_type == 1 # Value is a references to a resource
					# Find the resource
					default_res = apk_resources.get_default_resource_value(entry.data)
					if resolve_resources && default_res != nil
						# Use the default resource value
						attr_value = default_res.data
					else
						key_value = apk_resources.get_resource_key(entry.data, true)
						if key_value != nil
							# Use the key string
							attr_value = key_value
						else
							#No key found, use raw id marked as a resource
							attr_value = "res:0x#{entry.data.to_s(16)}"
						end
					end
				else # Value is a constant
					attr_value = "0x#{entry.data.to_s(16)}"
				end

				
				attributes << XmlAttribute.new(attr_namespace, attr_name, attr_value)
				i += 1
			end
			
			element = XmlElement.new(tree_header, namespace, name, id_idx, class_idx, style_idx, attributes, xml_output == "")
			
			# Print the element/attribute data
			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.value}" if DEBUG
				display_name = attr.namespace == nil ? attr.name : "#{attr.namespace}:#{attr.name}"
				if pretty
					xml_output += "\n" + ("  " * indent)
				end					
				xml_output += "#{display_name}=\"#{attr.value}\" "
			end
			
			xml_output += ">"
			
			# Push every new element onto the array
			@xml_elements << element
			
			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