揭秘Android逆向：探索二进制xml文件（Start Tag Chunk）的奥秘

2024-02-06 23:35:35

Android 逆向：深入解析二进制 XML 文件的开始标签 Chunk

在 Android 应用开发中，XML 文件发挥着至关重要的作用。它们用于定义用户界面布局、资源文件和配置文件等内容。然而，在 Android 系统中，这些 XML 文件经过编译后会变成不可读的二进制文件，给逆向工程带来了一定的挑战。

了解 Android 二进制 XML 文件

为了深入理解 Android 二进制 XML 文件，我们需要了解其内部结构。这些文件由一系列 Chunk 组成，每个 Chunk 都有自己的类型和内容。其中，开始标签 Chunk（Start Tag Chunk）是一个非常重要的 Chunk，它包含了 XML 元素开始标签的信息。

开始标签 Chunk 结构

开始标签 Chunk 的结构如下：

Chunk Type (4 字节)：0x00100102
Chunk Size (4 字节)：Chunk 的总大小，包括 Chunk 头和 Chunk 数据
Line Number (4 字节)：XML 元素在源码中的行号
Namespace URI Length (4 字节)：XML 元素的命名空间 URI 的长度
Namespace URI (可变长度)：XML 元素的命名空间 URI
Name Length (4 字节)：XML 元素名称的长度
Name (可变长度)：XML 元素名称
Attribute Count (4 字节)：XML 元素的属性数量
Attribute (可变长度)：XML 元素的属性列表，每个属性由属性名称、属性值和属性类型组成

解析开始标签 Chunk

我们可以使用 Java 代码来解析开始标签 Chunk。下面是一个示例代码：

import java.io.FileInputStream;
import java.io.IOException;

public class StartTagChunkParser {

    public static void main(String[] args) throws IOException {
        // 打开二进制 XML 文件
        FileInputStream fileInputStream = new FileInputStream("resources.arsc");

        // 读取 Chunk Type
        byte[] chunkTypeBytes = new byte[4];
        fileInputStream.read(chunkTypeBytes);
        int chunkType = bytesToInt(chunkTypeBytes);

        // 读取 Chunk Size
        byte[] chunkSizeBytes = new byte[4];
        fileInputStream.read(chunkSizeBytes);
        int chunkSize = bytesToInt(chunkSizeBytes);

        // 读取 Line Number
        byte[] lineNumberBytes = new byte[4];
        fileInputStream.read(lineNumberBytes);
        int lineNumber = bytesToInt(lineNumberBytes);

        // 读取 Namespace URI Length
        byte[] namespaceUriLengthBytes = new byte[4];
        fileInputStream.read(namespaceUriLengthBytes);
        int namespaceUriLength = bytesToInt(namespaceUriLengthBytes);

        // 读取 Namespace URI
        byte[] namespaceUriBytes = new byte[namespaceUriLength];
        fileInputStream.read(namespaceUriBytes);
        String namespaceUri = new String(namespaceUriBytes);

        // 读取 Name Length
        byte[] nameLengthBytes = new byte[4];
        fileInputStream.read(nameLengthBytes);
        int nameLength = bytesToInt(nameLengthBytes);

        // 读取 Name
        byte[] nameBytes = new byte[nameLength];
        fileInputStream.read(nameBytes);
        String name = new String(nameBytes);

        // 读取 Attribute Count
        byte[] attributeCountBytes = new byte[4];
        fileInputStream.read(attributeCountBytes);
        int attributeCount = bytesToInt(attributeCountBytes);

        // 读取 Attribute
        for (int i = 0; i < attributeCount; i++) {
            // 读取 Attribute Name Length
            byte[] attributeNameLengthBytes = new byte[4];
            fileInputStream.read(attributeNameLengthBytes);
            int attributeNameLength = bytesToInt(attributeNameLengthBytes);

            // 读取 Attribute Name
            byte[] attributeNameBytes = new byte[attributeNameLength];
            fileInputStream.read(attributeNameBytes);
            String attributeName = new String(attributeNameBytes);

            // 读取 Attribute Value Length
            byte[] attributeValueLengthBytes = new byte[4];
            fileInputStream.read(attributeValueLengthBytes);
            int attributeValueLength = bytesToInt(attributeValueLengthBytes);

            // 读取 Attribute Value
            byte[] attributeValueBytes = new byte[attributeValueLength];
            fileInputStream.read(attributeValueBytes);
            String attributeValue = new String(attributeValueBytes);

            // 读取 Attribute Type
            byte[] attributeTypeBytes = new byte[4];
            fileInputStream.read(attributeTypeBytes);
            int attributeType = bytesToInt(attributeTypeBytes);

            // 打印属性信息
            System.out.println("Attribute Name: " + attributeName);
            System.out.println("Attribute Value: " + attributeValue);
            System.out.println("Attribute Type: " + attributeType);
        }

        // 关闭文件
        fileInputStream.close();
    }

    private static int bytesToInt(byte[] bytes) {
        return (bytes[0] & 0xFF) << 24 | (bytes[1] & 0xFF) << 16 | (bytes[2] & 0xFF) << 8 | (bytes[3] & 0xFF);
    }
}