为什么 LC_SYMTAB 有无效的 stroff/strsize 但仅针对某些已加载的图像？

Question

我编写了以下程序来遍历内存中的所有图像并转储它们的字符串 tables。

#include <mach-o/dyld.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char** argv) {
    uint32_t count = _dyld_image_count();
    for (uint32_t i = 0 ; i < count ; i++) {
        const char* imageName = _dyld_get_image_name(i);
        printf("IMAGE[%u]=%s\n", i, imageName);
        const struct mach_header* header = _dyld_get_image_header(i);
        if (header->magic != MH_MAGIC_64)
            continue;
        struct mach_header_64* header64 = (struct mach_header_64*)header;
        char *ptr = ((void*)header64) + sizeof(struct mach_header_64);
        for (uint32_t j = 0; j < header64->ncmds; j++) {
            struct load_command *lc = (struct load_command *)ptr;
            ptr += lc->cmdsize;
            if (lc->cmd != LC_SYMTAB)
                continue;
            struct symtab_command* symtab = (struct symtab_command*)lc;
            printf("\t\tLC_SYMTAB.stroff=%u\n", symtab->stroff);
            printf("\t\tLC_SYMTAB.strsize=%u\n", symtab->strsize);
            if (symtab->strsize > 100*1024*1024) {
                printf("\t\tHUH? Don't believe string table is over 100MiB in size!\n");
                continue;
            }
            char *strtab = (((void*)header64) + symtab->stroff);
            uint32_t off = 0;
            while (off < symtab->strsize) {
                char *e = &(strtab[off]);
                if (e[0] != 0)
                    printf("\t\tSTR[%u]=\"%s\"\n", off, e);
                off += strlen(e) + 1;
            }
        }
    }
    return 0;
}

它似乎对某些图像随机起作用，但对于其他图像 stroff/strsize 具有无意义的值：

        LC_SYMTAB.stroff=1266154560
        LC_SYMTAB.strsize=143767728

这两个魔法值似乎总是相同的，但我不确定这是否在某种程度上取决于系统，或者其他人是否会得到相同的特定值。

如果我注释掉对 strsize 超过 100MiB 的检查，然后打印字符串 table 段错误。

大多数图像似乎都有这个问题，但有些则没有。当我运行它时，我得到了 38 张图像中的 29 张图像的问题。

我无法观察到关于哪些会哪些不会的模式。这是怎么回事？

如果相关，我正在 macOS 10.14.6 上测试并使用 Apple LLVM 版本 10.0.1 (clang-1001.0.46.4) 进行编译。

Answer 1

如您所计算，这些来自 dyld_shared_cache。并且 0x80000000 标志确实记录在 header 中，随 Xcode 或 any semi-recent XNU source:

#define MH_DYLIB_IN_CACHE 0x80000000    /* Only for use on dylibs. When this bit
                                           is set, the dylib is part of the dyld
                                           shared cache, rather than loose in
                                           the filesystem. */

正如您还发现的那样，stroff/strsize 值在添加到 dyld_shared_cache 基数时不会产生可用的结果。那是因为那些不是 memory 偏移量，而是 file 偏移量。对于所有 Mach-O 都是如此，通常情况下 non-cached 二进制文件的段在文件和内存偏移量中具有相同的相对位置。但是共享缓存绝对不是这样。

要将文件偏移量转换为内存地址，您必须解析共享缓存中的段 header。您可以找到结构定义 in the dyld source.

Answer 2

这是一个打印 dyld 共享缓存的字符串 table 内容的程序。

我在问题中的原始程序可以增强以跳过转储设置了 MH_DYLIB_IN_CACHE 的图像的字符串 table，并结合此程序转储共享缓存字符串 table。（共享缓存中的所有图像共享相同的字符串 table。）

#include <mach-o/dyld.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>

const void* _dyld_get_shared_cache_range(size_t* cacheLen);

struct dyld_cache_header {
        char            magic[16];
        uint32_t        mappingOffset;
        uint32_t        mappingCount;
        // Omitted remaining fields, not relevant to this task
};

struct dyld_cache_mapping_info {
    uint64_t    address;
    uint64_t    size;
    uint64_t    fileOffset;
    uint32_t    maxProt;
    uint32_t    initProt;
};

#ifndef MH_DYLIB_IN_CACHE
#       define MH_DYLIB_IN_CACHE 0x80000000
#endif

// Finds first shared cache DYLD image. Any will do, just grab the first
const struct mach_header_64* findSharedCacheDyldImage(void) {
        uint32_t count = _dyld_image_count();
        for (uint32_t i = 0 ; i < count ; i++) {
                const struct mach_header* header = _dyld_get_image_header(i);
                if (header->magic != MH_MAGIC_64)
                        continue;
                const struct mach_header_64* header64 = (const struct mach_header_64*)header;
                if (!(header64->flags & MH_DYLIB_IN_CACHE))
                        continue;
                return header64;
        }
        return NULL;
}

// Find first instance of given load command in image
const struct load_command* findFirstLoadCommand(const struct mach_header_64* header64, uint32_t cmd) {
        const char *ptr = ((void*)header64) + sizeof(struct mach_header_64);
        for (uint32_t j = 0; j < header64->ncmds; j++) {
                const struct load_command *lc = (const struct load_command *)ptr;
                ptr += lc->cmdsize;
                if (lc->cmd == cmd)
                        return lc;
        }
        return NULL;
}

// Translates a shared cache file offset to a memory address
void *translateOffset(const struct dyld_cache_header *cache, uint64_t offset) {
        const struct dyld_cache_mapping_info* mappings = (struct dyld_cache_mapping_info*)(((void*)cache) + cache->mappingOffset);
        for (uint32_t i = 0; i < cache->mappingCount; i++) {
                if (offset < mappings[i].fileOffset) continue;
                if (offset >= (mappings[i].fileOffset + mappings[i].size)) continue;
                return (void*)(mappings[i].address - mappings[0].address + (offset - mappings[i].fileOffset) + (uint64_t)cache);
        }
        return NULL;
}

int main(int argc, char** argv) {
        size_t cacheLen;
        const struct dyld_cache_header *cache = _dyld_get_shared_cache_range(&cacheLen);
        const struct mach_header_64* sharedCacheDyldImage = findSharedCacheDyldImage();
        const struct symtab_command* symtab = (const struct symtab_command*)findFirstLoadCommand(sharedCacheDyldImage,LC_SYMTAB);
        const void *stringTbl = translateOffset(cache, symtab->stroff);
        uint32_t off = 0;
        while (off < symtab->strsize) {
                const char *e = &(stringTbl[off]);
                if (e[0] != 0)
                        printf("STR[%u]=\"%s\"\n", off, e);
                off += strlen(e) + 1;
        }
        return 0;
}

为什么 LC_SYMTAB 有无效的 stroff/strsize 但仅针对某些已加载的图像？

Why does LC_SYMTAB have invalid stroff/strsize but only for some loaded images?

c

macos

mach-o

dyld