rz_axml.h File Reference

#include <rz_types.h>

Go to the source code of this file.

Functions
RZ_API RZ_OWN char *	rz_axml_decode (RZ_NONNULL const ut8 *buffer, const ut64 size)
	Decode a buffer with Android XML to regular XML string representation. More...

Function Documentation

rz_axml_decode()

RZ_API RZ_OWN char* rz_axml_decode	(	RZ_NONNULL const ut8 *	data,
		const ut64	data_size
	)

Decode a buffer with Android XML to regular XML string representation.

Parameters

data	Buffer containing the AXML data
data_size	Size of the buffer data

Returns

String with the regular XML string

Definition at line 303 of file axml.c.

                                                                                     {
    string_pool_t *pool = NULL;
    namespace_t *namespace = NULL;
    const ut32 *resource_map = NULL;
    ut32 resource_map_length = 0;
    RzStrBuf *sb = NULL;
    st32 depth = 0;
 
    rz_return_val_if_fail(data, NULL);
    if (data_size == 0) {
        return strdup("");
    }
 
    RzBuffer *buffer = rz_buf_new_with_pointers(data, data_size, false);
    if (!buffer) {
        RZ_LOG_ERROR("Error allocating RzBuffer\n");
        goto error;
    }
 
    ut64 offset = 0;
 
    chunk_header_t header = { 0 };
    if (rz_buf_fread_at(buffer, offset, (ut8 *)&header, "ssi", 1) != sizeof(header)) {
        goto bad;
    }
 
    if (header.type != TYPE_XML) {
        goto bad;
    }
 
    ut64 binary_size = header.size;
    if (binary_size > data_size) {
        goto bad;
    }
 
    offset += sizeof(header);
 
    sb = rz_strbuf_new("");
 
    while (offset < binary_size) {
        if (rz_buf_fread_at(buffer, offset, (ut8 *)&header, "ssi", 1) != sizeof(header)) {
            goto bad;
        }
 
        ut16 type = header.type;
 
        // After reading the original chunk header, read the type-specific
        // header
        offset += sizeof(header);
 
        switch (type) {
        case TYPE_STRING_POOL: {
            ut16 header_size = header.size;
            if (header_size == 0 || header_size > data_size) {
                goto bad;
            }
 
            pool = malloc(header_size);
            if (!pool) {
                goto bad;
            }
 
            if (rz_buf_read_at(buffer, offset, (void *)pool, header_size) != header_size) {
                goto bad;
            }
            break;
        }
        case TYPE_START_ELEMENT: {
            // The string pool must be the first header
            if (!pool) {
                goto bad;
            }
 
            ut16 header_size = header.size;
            if (header_size == 0 || header_size > data_size) {
                goto bad;
            }
 
            start_element_t *element = malloc(header_size);
            if (!element) {
                goto bad;
            }
 
            if (rz_buf_read_at(buffer, offset, (void *)element, header_size) != header_size) {
                free(element);
                goto bad;
            }
 
            if (!dump_element(sb, pool, namespace, data, data_size, element,
                    resource_map, resource_map_length, &depth, true)) {
                free(element);
                goto bad;
            }
 
            depth++;
 
            free(element);
            break;
        }
        case TYPE_END_ELEMENT: {
            depth--;
            if (depth < 0) {
                goto bad;
            }
 
            end_element_t end;
            if (rz_buf_read_at(buffer, offset, (void *)&end, sizeof(end)) != sizeof(end)) {
                goto bad;
            }
 
            // The beginning of the start and end element structs
            // are the same, so we can use this interchangably
            if (!dump_element(sb, pool, namespace, data, data_size, (start_element_t *)&end,
                    resource_map, resource_map_length, &depth, false)) {
                goto bad;
            }
            break;
        }
        case TYPE_START_NAMESPACE:
            // If there is already a start namespace, override it
            free(namespace);
            namespace = malloc(sizeof(*namespace));
            if (rz_buf_fread_at(buffer, offset, (ut8 *)namespace, "iiii", 1) != sizeof(*namespace)) {
                goto bad;
            }
            break;
        case TYPE_END_NAMESPACE:
            break;
        case TYPE_RESOURCE_MAP:
            resource_map = (ut32 *)(data + offset);
            resource_map_length = header.size;
            if (resource_map_length > data_size - offset) {
                goto bad;
            }
            resource_map_length /= sizeof(ut32);
            break;
        default:
            RZ_LOG_WARN("Type is not recognized: %#x\n", type);
        }
 
        offset += header.size - sizeof(header);
    }
 
    rz_buf_free(buffer);
    free(pool);
    free(namespace);
    return rz_strbuf_drain(sb);
bad:
    RZ_LOG_ERROR("Invalid Android Binary XML\n");
error:
    if (buffer)
        rz_buf_free(buffer);
    free(pool);
    rz_strbuf_free(sb);
    return NULL;
}

References dump_element(), test_evm::end, end_element_t, error(), free(), header, malloc(), NULL, rz_buf_fread_at(), rz_buf_free(), rz_buf_new_with_pointers(), rz_buf_read_at(), RZ_LOG_ERROR, RZ_LOG_WARN, rz_return_val_if_fail, rz_strbuf_drain(), rz_strbuf_free(), rz_strbuf_new(), sb, st32, strdup(), string_pool_t, type, TYPE_END_ELEMENT, TYPE_END_NAMESPACE, TYPE_RESOURCE_MAP, TYPE_START_ELEMENT, TYPE_START_NAMESPACE, TYPE_STRING_POOL, TYPE_XML, and ut64().

Referenced by cmd_print_fromage().