Introduction: The Heart of Android Resources

The resources.arsc file is a critical component within any Android application’s APK, serving as the binary table mapping resource IDs to their corresponding values and configurations. While tools like aapt (Android Asset Packaging Tool) or APKTool can easily decompile and interpret this file, understanding its byte-level structure is invaluable for advanced reverse engineering, custom tool development, and in situations where standard tools fall short. This guide will walk you through the fundamental building blocks of resources.arsc, from its generic chunk headers to the intricate mapping of resource entries.

Understanding the Core Structure: Chunks and Headers

At its heart, resources.arsc is a sequence of binary chunks, each prefixed by a standard Res_Chunk_header. This header provides essential information, allowing parsers to navigate the file structure.

struct Res_Chunk_header {    uint16 type;       // Type of chunk (e.g., RES_TABLE_TYPE, RES_STRING_POOL_TYPE)    uint16 headerSize; // Size of this chunk's header (e.g., 8 bytes for Res_Chunk_header)    uint32 size;       // Total size of this chunk, including header and data};

The type field is crucial, indicating what kind of data follows. Common types include RES_TABLE_TYPE for the root resource table, RES_STRING_POOL_TYPE for string pools, RES_TABLE_PACKAGE_TYPE for individual packages, and so on.

The Global String Pool (RES_STRING_POOL_TYPE)

One of the first chunks encountered after the main ResTable_header is typically a global string pool. This pool stores frequently used strings like package names, application labels, and other global metadata. Understanding its structure is key to resolving human-readable text from numeric indices.

ResStringPool_header and String Data

struct ResStringPool_header {    Res_Chunk_header header; // Type: RES_STRING_POOL_TYPE    uint32 stringCount;    uint32 styleCount; // Usually 0    uint32 flags;      // Bit 0: UTF-8 encoding (else UTF-16)    uint32 stringsStart; // Offset from header to strings data    uint32 stylesStart;  // Offset from header to styles data (usually 0)    // Followed by string offset array (stringCount entries, uint32 each)};

After the ResStringPool_header, there’s an array of uint32 offsets. Each offset points to the start of a string within the subsequent string data section, relative to the stringsStart field. Strings are null-terminated, and their encoding (UTF-8 or UTF-16) is indicated by the flags field.

The Resource Table (ResTable_header)

The entire resources.arsc file begins with a ResTable_header, which acts as the root of the resource table.

struct ResTable_header {    Res_Chunk_header header; // Type: RES_TABLE_TYPE    uint32 packageCount;     // Number of packages in this resource table};

This header immediately follows the global string pool and indicates how many resource packages (e.g., the app’s own resources, or framework resources) are defined within this .arsc file.

Deconstructing Packages (ResTable_package)

Each application or library defines its resources within a ResTable_package chunk. This chunk groups resources by their package ID and contains its own set of string pools for type and key names specific to that package.

struct ResTable_package {    Res_Chunk_header header; // Type: RES_TABLE_PACKAGE_TYPE    uint32 id;               // Package ID (e.g., 0x7f for app's resources)    char name[128];          // Package name (UTF-16, 64 characters max)    uint32 typeStrings;      // Offset to type string pool relative to package chunk start    uint32 lastPublicType;    uint32 keyStrings;       // Offset to key string pool relative to package chunk start    uint32 lastPublicKey;    // Followed by type and key string pools, then type spec/type chunks};

The typeStrings and keyStrings fields point to two crucial string pools within the package: one for resource type names (e.g.,