dyldcache_rebase.c File Reference

#include "dyldcache.h"

Go to the source code of this file.

Classes
struct	BufCtx

Macros
#define	RZ_IS_PTR_AUTHENTICATED(x)   B_IS_SET(x, 63)

Functions
static void	rebase_bytes_v1 (RzDyldRebaseInfo1 *rebase_info, ut8 *buf, ut64 offset, int count, ut64 start_of_write)
static void	rebase_bytes_v2 (RzDyldRebaseInfo2 *rebase_info, ut8 *buf, ut64 offset, int count, ut64 start_of_write)
static void	rebase_bytes_v3 (RzDyldRebaseInfo3 *rebase_info, ut8 *buf, ut64 offset, int count, ut64 start_of_write)
static RzDyldRebaseInfo *	rebase_info_by_range (RzDyldRebaseInfos *infos, ut64 offset, ut64 count)
static void	rebase_bytes (RzDyldRebaseInfo *rebase_info, ut8 *buf, ut64 offset, int count, ut64 start_of_write)
static bool	buf_init (RzBuffer *b, const void *user)
static bool	buf_fini (RzBuffer *b)
static bool	buf_resize (RzBuffer *b, ut64 newsize)
static st64	buf_read (RzBuffer *b, ut8 *buf, ut64 len)
static st64	buf_write (RzBuffer *b, const ut8 *buf, ut64 len)
static ut64	buf_get_size (RzBuffer *b)
static st64	buf_seek (RzBuffer *b, st64 addr, int whence)
static ut8 *	buf_get_whole_buf (RzBuffer *b, ut64 *sz)
RZ_API RzBuffer *	rz_dyldcache_new_rebasing_buf (RzDyldCache *cache)
RZ_API bool	rz_dyldcache_needs_rebasing (RzDyldCache *cache)
RZ_API bool	rz_dyldcache_range_needs_rebasing (RzDyldCache *cache, ut64 paddr, ut64 size)

Variables
static const RzBufferMethods	buf_methods

Macro Definition Documentation

RZ_IS_PTR_AUTHENTICATED

#define RZ_IS_PTR_AUTHENTICATED

(

x

)

B_IS_SET(x, 63)

Definition at line 89 of file dyldcache_rebase.c.

Function Documentation

buf_fini()

static bool buf_fini ( RzBuffer *  b )

static

Definition at line 191 of file dyldcache_rebase.c.

                                  {
    BufCtx *ctx = b->priv;
    free(ctx);
    return true;
}

References b, and free().

buf_get_size()

static ut64 buf_get_size ( RzBuffer *  b )

static

Definition at line 253 of file dyldcache_rebase.c.

                                      {
    BufCtx *ctx = b->priv;
    return rz_buf_size(ctx->cache->buf);
}

References b, and rz_buf_size().

buf_get_whole_buf()

static ut8* buf_get_whole_buf ( RzBuffer *  b, ut64 *  sz  )

static

Definition at line 263 of file dyldcache_rebase.c.

                                                     {
    BufCtx *ctx = b->priv;
    return (ut8 *)rz_buf_data(ctx->cache->buf, sz);
}

References b, and rz_buf_data().

buf_init()

static bool buf_init ( RzBuffer *  b, const void *  user  )

static

Definition at line 181 of file dyldcache_rebase.c.

                                                    {
    BufCtx *ctx = RZ_NEW0(BufCtx);
    if (!ctx) {
        return false;
    }
    ctx->cache = (void *)user;
    b->priv = ctx;
    return true;
}

References b, and RZ_NEW0.

buf_read()

static st64 buf_read ( RzBuffer *  b, ut8 *  buf, ut64  len  )

static

Definition at line 202 of file dyldcache_rebase.c.

                                                      {
    BufCtx *ctx = b->priv;
    st64 r = rz_buf_read_at(ctx->cache->buf, ctx->off, buf, len);
    if (r <= 0 || !len) {
        return r;
    }
 
    RzDyldCache *cache = ctx->cache;
    RzDyldRebaseInfo *rebase_info = rebase_info_by_range(cache->rebase_infos, ctx->off, len);
 
    if (!rebase_info) {
        return rz_buf_read_at(cache->buf, ctx->off, buf, len);
    }
    st64 result = 0;
    ut64 offset_in_data = ctx->off - rebase_info->start_of_data;
    ut64 page_offset = offset_in_data % rebase_info->page_size;
 
    ut64 internal_offset = ctx->off & ~(rebase_info->page_size - 1);
    ut64 internal_end = ctx->off + len;
    int rounded_count = internal_end - internal_offset;
 
    ut8 *internal_buf = rebase_info->one_page_buf;
    if (rounded_count > rebase_info->page_size) {
        internal_buf = malloc(rounded_count);
        if (!internal_buf) {
            RZ_LOG_ERROR("Cannot allocate memory for 'internal_buf'\n");
            return -1;
        }
    }
 
    st64 internal_result = rz_buf_read_at(cache->buf, internal_offset, internal_buf, rounded_count);
    if (internal_result >= page_offset + len) {
        rebase_bytes(rebase_info, internal_buf, internal_offset, internal_result, page_offset);
        result = RZ_MIN(len, internal_result);
        memcpy(buf, internal_buf + page_offset, result);
    } else {
        RZ_LOG_ERROR("Cannot rebase\n");
        result = rz_buf_read_at(cache->buf, ctx->off, buf, len);
    }
 
    if (internal_buf != rebase_info->one_page_buf) {
        RZ_FREE(internal_buf);
    }
    return result;
}

References b, rz_dyldcache_t::buf, len, malloc(), memcpy(), rz_dyld_rebase_info_t::one_page_buf, rz_dyld_rebase_info_t::page_size, r, rebase_bytes(), rebase_info_by_range(), rz_dyldcache_t::rebase_infos, rz_buf_read_at(), RZ_FREE, RZ_LOG_ERROR, RZ_MIN, st64, rz_dyld_rebase_info_t::start_of_data, and ut64().

Referenced by LoadCentralDirectoryRecord().

buf_resize()

static bool buf_resize ( RzBuffer *  b, ut64  newsize  )

static

Definition at line 197 of file dyldcache_rebase.c.

                                                  {
    BufCtx *ctx = b->priv;
    return rz_buf_resize(ctx->cache->buf, newsize);
}

References b, and rz_buf_resize().

buf_seek()

static st64 buf_seek ( RzBuffer *  b, st64  addr, int  whence  )

static

Definition at line 258 of file dyldcache_rebase.c.

                                                         {
    BufCtx *ctx = b->priv;
    return ctx->off = rz_seek_offset(ctx->off, rz_buf_size(b), addr, whence);
}

References addr, b, rz_buf_size(), and rz_seek_offset().

buf_write()

static st64 buf_write ( RzBuffer *  b, const ut8 *  buf, ut64  len  )

static

Definition at line 248 of file dyldcache_rebase.c.

                                                             {
    BufCtx *ctx = b->priv;
    return rz_buf_write_at(ctx->cache->buf, ctx->off, buf, len);
}

References b, len, and rz_buf_write_at().

rebase_bytes()

static void rebase_bytes ( RzDyldRebaseInfo *  rebase_info, ut8 *  buf, ut64  offset, int  count, ut64  start_of_write  )

static

Definition at line 162 of file dyldcache_rebase.c.

                                                                                                               {
    if (!rebase_info || !buf) {
        return;
    }
 
    if (rebase_info->version == 3) {
        rebase_bytes_v3((RzDyldRebaseInfo3 *)rebase_info, buf, offset, count, start_of_write);
    } else if (rebase_info->version == 2 || rebase_info->version == 4) {
        rebase_bytes_v2((RzDyldRebaseInfo2 *)rebase_info, buf, offset, count, start_of_write);
    } else if (rebase_info->version == 1) {
        rebase_bytes_v1((RzDyldRebaseInfo1 *)rebase_info, buf, offset, count, start_of_write);
    }
}

References count, rebase_bytes_v1(), rebase_bytes_v2(), rebase_bytes_v3(), and rz_dyld_rebase_info_t::version.

Referenced by buf_read().

rebase_bytes_v1()

static void rebase_bytes_v1 ( RzDyldRebaseInfo1 *  rebase_info, ut8 *  buf, ut64  offset, int  count, ut64  start_of_write  )

static

Definition at line 7 of file dyldcache_rebase.c.

                                                                                                                   {
    int in_buf = 0;
    while (in_buf < count) {
        ut64 offset_in_data = offset - rebase_info->start_of_data;
        ut64 page_index = offset_in_data / rebase_info->page_size;
        ut64 page_offset = offset_in_data % rebase_info->page_size;
        ut64 to_next_page = rebase_info->page_size - page_offset;
        ut64 entry_index = page_offset / 32;
        ut64 offset_in_entry = (page_offset % 32) / 4;
 
        if (entry_index >= rebase_info->entries_size) {
            in_buf += to_next_page;
            offset += to_next_page;
            continue;
        }
 
        if (page_index >= rebase_info->toc_count) {
            break;
        }
 
        ut8 *entry = &rebase_info->entries[rebase_info->toc[page_index] * rebase_info->entries_size];
        ut8 b = entry[entry_index];
 
        if (b & (1 << offset_in_entry)) {
            ut64 value = rz_read_le64(buf + in_buf);
            value += rebase_info->slide;
            rz_write_le64(buf + in_buf, value);
            in_buf += 8;
            offset += 8;
        } else {
            in_buf += 4;
            offset += 4;
        }
    }
}

References b, count, rz_dyld_rebase_info_1_t::entries, rz_dyld_rebase_info_1_t::entries_size, in_buf, page_index, rz_dyld_rebase_info_1_t::page_size, rz_read_le64(), rz_write_le64(), rz_dyld_rebase_info_1_t::slide, rz_dyld_rebase_info_1_t::start_of_data, rz_dyld_rebase_info_1_t::toc, rz_dyld_rebase_info_1_t::toc_count, ut64(), and value.

Referenced by rebase_bytes().

rebase_bytes_v2()

static void rebase_bytes_v2 ( RzDyldRebaseInfo2 *  rebase_info, ut8 *  buf, ut64  offset, int  count, ut64  start_of_write  )

static

Definition at line 43 of file dyldcache_rebase.c.

                                                                                                                   {
    int in_buf = 0;
    while (in_buf < count) {
        ut64 offset_in_data = offset - rebase_info->start_of_data;
        ut64 page_index = offset_in_data / rebase_info->page_size;
        ut64 page_offset = offset_in_data % rebase_info->page_size;
        ut64 to_next_page = rebase_info->page_size - page_offset;
 
        if (page_index >= rebase_info->page_starts_count) {
            goto next_page;
        }
        ut16 page_flag = rebase_info->page_starts[page_index];
 
        if (page_flag == DYLD_CACHE_SLIDE_PAGE_ATTR_NO_REBASE) {
            goto next_page;
        }
 
        if (!(page_flag & DYLD_CACHE_SLIDE_PAGE_ATTR_EXTRA)) {
            ut64 first_rebase_off = rebase_info->page_starts[page_index] * 4;
            if (first_rebase_off >= page_offset && first_rebase_off < page_offset + count) {
                ut32 delta = 1;
                while (delta) {
                    ut64 position = in_buf + first_rebase_off - page_offset;
                    if (position >= count) {
                        break;
                    }
                    ut64 raw_value = rz_read_le64(buf + position);
                    delta = ((raw_value & rebase_info->delta_mask) >> rebase_info->delta_shift);
                    if (position >= start_of_write) {
                        ut64 new_value = raw_value & rebase_info->value_mask;
                        if (new_value != 0) {
                            new_value += rebase_info->value_add;
                            new_value += rebase_info->slide;
                        }
                        rz_write_le64(buf + position, new_value);
                    }
                    first_rebase_off += delta;
                }
            }
        }
    next_page:
        in_buf += to_next_page;
        offset += to_next_page;
    }
}

References count, delta, rz_dyld_rebase_info_2_t::delta_mask, rz_dyld_rebase_info_2_t::delta_shift, DYLD_CACHE_SLIDE_PAGE_ATTR_EXTRA, DYLD_CACHE_SLIDE_PAGE_ATTR_NO_REBASE, in_buf, page_index, rz_dyld_rebase_info_2_t::page_size, rz_dyld_rebase_info_2_t::page_starts, rz_dyld_rebase_info_2_t::page_starts_count, rz_read_le64(), rz_write_le64(), rz_dyld_rebase_info_2_t::slide, rz_dyld_rebase_info_2_t::start_of_data, ut64(), rz_dyld_rebase_info_2_t::value_add, and rz_dyld_rebase_info_2_t::value_mask.

Referenced by rebase_bytes().

rebase_bytes_v3()

static void rebase_bytes_v3 ( RzDyldRebaseInfo3 *  rebase_info, ut8 *  buf, ut64  offset, int  count, ut64  start_of_write  )

static

Definition at line 91 of file dyldcache_rebase.c.

                                                                                                                   {
    int in_buf = 0;
    while (in_buf < count) {
        ut64 offset_in_data = offset - rebase_info->start_of_data;
        ut64 page_index = offset_in_data / rebase_info->page_size;
        ut64 page_offset = offset_in_data % rebase_info->page_size;
        ut64 to_next_page = rebase_info->page_size - page_offset;
 
        if (page_index >= rebase_info->page_starts_count) {
            goto next_page;
        }
        ut64 delta = rebase_info->page_starts[page_index];
 
        if (delta == DYLD_CACHE_SLIDE_V3_PAGE_ATTR_NO_REBASE) {
            goto next_page;
        }
 
        ut64 first_rebase_off = delta;
        if (first_rebase_off >= page_offset && first_rebase_off < page_offset + count) {
            do {
                ut64 position = in_buf + first_rebase_off - page_offset;
                if (position >= count) {
                    break;
                }
                ut64 raw_value = rz_read_le64(buf + position);
                delta = ((raw_value & rebase_info->delta_mask) >> rebase_info->delta_shift) * 8;
                if (position >= start_of_write) {
                    ut64 new_value = 0;
                    if (RZ_IS_PTR_AUTHENTICATED(raw_value)) {
                        new_value = (raw_value & 0xFFFFFFFFULL) + rebase_info->auth_value_add;
                        // TODO: don't throw auth info away
                    } else {
                        new_value = ((raw_value << 13) & 0xFF00000000000000ULL) | (raw_value & 0x7ffffffffffULL);
                        new_value &= 0x00FFFFFFFFFFFFFFULL;
                    }
                    if (new_value != 0) {
                        new_value += rebase_info->slide;
                    }
                    rz_write_le64(buf + position, new_value);
                }
                first_rebase_off += delta;
            } while (delta);
        }
    next_page:
        in_buf += to_next_page;
        offset += to_next_page;
    }
}

References rz_dyld_rebase_info_3_t::auth_value_add, count, delta, rz_dyld_rebase_info_3_t::delta_mask, rz_dyld_rebase_info_3_t::delta_shift, DYLD_CACHE_SLIDE_V3_PAGE_ATTR_NO_REBASE, in_buf, page_index, rz_dyld_rebase_info_3_t::page_size, rz_dyld_rebase_info_3_t::page_starts, rz_dyld_rebase_info_3_t::page_starts_count, RZ_IS_PTR_AUTHENTICATED, rz_read_le64(), rz_write_le64(), rz_dyld_rebase_info_3_t::slide, rz_dyld_rebase_info_3_t::start_of_data, and ut64().

Referenced by rebase_bytes().

rebase_info_by_range()

static RzDyldRebaseInfo* rebase_info_by_range ( RzDyldRebaseInfos *  infos, ut64  offset, ut64  count  )

static

Definition at line 140 of file dyldcache_rebase.c.

                                                                                                 {
    int imid;
    int imin = 0;
    int imax = infos->length - 1;
 
    while (imin < imax) {
        imid = (imin + imax) / 2;
        RzDyldRebaseInfosEntry *entry = &infos->entries[imid];
        if ((entry->end) <= offset) {
            imin = imid + 1;
        } else {
            imax = imid;
        }
    }
 
    RzDyldRebaseInfosEntry *minEntry = &infos->entries[imin];
    if ((imax == imin) && (minEntry->start <= offset + count) && (minEntry->end >= offset)) {
        return minEntry->info;
    }
    return NULL;
}

References count, rz_dyld_rebase_infos_entry_t::end, rz_dyld_rebase_infos_t::entries, rz_dyld_rebase_infos_entry_t::info, rz_dyld_rebase_infos_t::length, NULL, and rz_dyld_rebase_infos_entry_t::start.

Referenced by buf_read(), and rz_dyldcache_range_needs_rebasing().

rz_dyldcache_needs_rebasing()

RZ_API bool rz_dyldcache_needs_rebasing

(

RzDyldCache *

cache

)

Definition at line 284 of file dyldcache_rebase.c.

                                                            {
    rz_return_val_if_fail(cache, false);
    if (cache->rebase_infos) {
        if (!rz_dyldcache_get_slide(cache)) {
            return true;
        }
    }
    return false;
}

References rz_dyldcache_t::rebase_infos, rz_dyldcache_get_slide(), and rz_return_val_if_fail.

Referenced by classes(), rz_dyldcache_range_needs_rebasing(), and virtual_files().

rz_dyldcache_new_rebasing_buf()

RZ_API RzBuffer* rz_dyldcache_new_rebasing_buf

(

RzDyldCache *

cache

)

Definition at line 279 of file dyldcache_rebase.c.

                                                                   {
    rz_return_val_if_fail(cache, NULL);
    return rz_buf_new_with_methods(&buf_methods, cache);
}

References buf_methods, NULL, rz_buf_new_with_methods(), and rz_return_val_if_fail.

Referenced by classes(), and virtual_files().

rz_dyldcache_range_needs_rebasing()

RZ_API bool rz_dyldcache_range_needs_rebasing	(	RzDyldCache *	cache,
		ut64	paddr,
		ut64	size
	)

Definition at line 294 of file dyldcache_rebase.c.

                                                                                         {
    rz_return_val_if_fail(cache, false);
    if (!rz_dyldcache_needs_rebasing(cache)) {
        return false;
    }
    return !!rebase_info_by_range(cache->rebase_infos, paddr, size);
}

References rebase_info_by_range(), rz_dyldcache_t::rebase_infos, rz_dyldcache_needs_rebasing(), and rz_return_val_if_fail.

Referenced by maps().

Variable Documentation

buf_methods

const RzBufferMethods buf_methods

static

Initial value:

= {
    .init = buf_init,
    .fini = buf_fini,
    .read = buf_read,
    .write = buf_write,
    .get_size = buf_get_size,
    .resize = buf_resize,
    .seek = buf_seek,
    .get_whole_buf = buf_get_whole_buf
}

Definition at line 268 of file dyldcache_rebase.c.

Referenced by rz_dyldcache_new_rebasing_buf().