← 返回列表

IOS 代码签名深度分析

单站 kernsec 发布 Sat, 03 Jan 2026 08:34:00 +0800 入库 2026-11-18T07:54:04

原创 wzt 2026-01-03 08:34 浙江

OS的代码签名机制是套复杂的系统工程,本文从用户态工具到内核态处理流程对ios代码签名机制做深度分析

1 简介

IOS的代码签名机制是套复杂的系统工程,本文从用户态工具到内核态处理流程对ios代码签名机制做一个完全的分析。

苹果公司的objectc和swift语言经过编译后的二进制文件为mach-o格式,这是苹果公司自己设计的一个二进制文件格式,通过xcode的签名工具将签名信息保存在macho文件的一个特定section:LC_CODE_SIGNATURE。

苹果公司对macho的签名包含两种信息,第一个信息是文件的hash,以页为单位算出hash值,将所有的hash值保存在上述section里。另一个信息是由苹果公司签发的证书信息。证书用来证明app的来源可靠,hash值用来检测每次app启动时的完整性,确保不被篡改。

xcode调用codesign用户态工具,对app进行签名,签名信息被llvm编译器链接进macho里,它被表示成一个数据结构为:

osfmk/kern/cs_blobs.h

typedef struct __CodeDirectory {

uint32_t magic;                                 /* magic number (CSMAGIC_CODEDIRECTORY) */

uint32_t length;                                /* total length of CodeDirectory blob */

uint32_t version;                               /* compatibility version */

uint32_t flags;                                 /* setup and mode flags */

uint32_t hashOffset;                    /* offset of hash slot element at index zero */

uint32_t identOffset;                   /* offset of identifier string */

uint32_t nSpecialSlots;                 /* number of special hash slots */

uint32_t nCodeSlots;                    /* number of ordinary (code) hash slots */

uint32_t codeLimit;                             /* limit to main image signature range */

uint8_t hashSize;                               /* size of each hash in bytes */

...

uint8_t hashType;

} CS_CodeDirectory

__attribute__ ((aligned(1)));

其中hashOffset保存的就是文件以页为单位的所有sha256 hash。macos系统没有自带的工具能识别出这些hash,可以使用开源的jtool2工具,本文使用笔者自己开发的一个工具ikit工具来解析签名信息。

它可以分析ios的kernelcache,解析device tree, 提取kext,解析macho文件的hash信息、entitlements以及cms信息。

使用--sig参数提取safari的所有hash信息。

./ikit --sig -v /Applications/Safari.app/Contents/MacOS/Safari >safari.hash
CodeDirectory除了保存文件的hash值以外,还会保存另外七个特殊类型的hash:

CSSLOT_CODEDIRECTORY = 0,                               /* slot index for CodeDirectory */

CSSLOT_INFOSLOT = 1,

CSSLOT_REQUIREMENTS = 2,

CSSLOT_RESOURCEDIR = 3,

CSSLOT_APPLICATION = 4,

CSSLOT_ENTITLEMENTS = 5,

CSSLOT_DER_ENTITLEMENTS = 7,

CSSLOT_DER_ENTITLEMENTS是苹果公司在新版macos/ios中新加入的entitlements类型,用DER格式表示。

Entitlements是整个xml信息的hash值,使用ikit的--ent参数可以提取出所有的entitlements列表。

./ikit --ent -v /Applications/Safari.app/Contents/MacOS/Safari >safari.ent
IOS的代码签名过程分为启动前、运行时、退出时。

3.1.1 进程启动前验签过程

签名的解析发生在macho从磁盘加载到内核的过程中。

bsd/kern/mach_loader.c

parse_machfile(

struct vnode            *vp,

vm_map_t                map,

thread_t                thread,

struct mach_header      *header,

off_t                   file_offset,

off_t                   macho_size,

int                     depth,

int64_t                 aslr_offset,

int64_t                 dyld_aslr_offset,

load_result_t           *result,

load_result_t           *binresult,

struct image_params     *imgp

)

{

if (os_add_overflow(mach_header_sz, header->sizeofcmds, &cmds_size) ||

(off_t)cmds_size > macho_size ||

round_page_overflow(cmds_size, &alloc_size) ||

alloc_size > INT_MAX) {

return LOAD_BADMACHO;

}

addr = kalloc_data(alloc_size, Z_WAITOK);

if (addr == NULL) {

return LOAD_NOSPACE;

}

error = vn_rdwr(UIO_READ, vp, addr, (int)alloc_size, file_offset,

UIO_SYSSPACE, 0, vfs_context_ucred(imgp->ip_vfs_context), &resid, p);

if (error) {

kfree_data(addr, alloc_size);

return LOAD_IOERROR;

}

请注意xnu一次性将command全部从磁盘读入内存, text段等都包含在其内,这为后面校验hash提供了方便。

...

case LC_CODE_SIGNATURE:

ret = load_code_signature(

(struct linkedit_data_command *) lcp,

vp,

file_offset,

macho_size,

header->cputype,

header->cpusubtype,

result,

imgp);

while (off < alloc_size && ret == LOAD_SUCCESS) {

tainted = CS_VALIDATE_TAINTED;

valid = cs_validate_range(vp,

NULL,

ile_offset + off,

(const void *)((uintptr_t)addr + off),

MIN(PAGE_SIZE, cmds_size),

&tainted);

}

}

load_code_signature用来解析签名信息。

staticload_return_t

load_code_signature(

struct linkedit_data_command    *lcp,

struct vnode                    *vp,

off_t                           macho_offset,

off_t                           macho_size,

cpu_type_t                      cputype,

cpu_subtype_t                   cpusubtype,

load_result_t                   *result,

struct image_params             *imgp)

{

blob = ubc_cs_blob_get(vp, cputype, cpusubtype, macho_offset);

if (blob != NULL) {

return;

}

首先从文件vnode节点中提取出一个struct cs_blob结构,它保存的是签名信息,如果这个签名信息已经存在,则直接返回成功。

kr = ubc_cs_blob_allocate(&addr, &blob_size);

if (kr != KERN_SUCCESS) {

ret = LOAD_NOSPACE;

goto out;

}

resid = 0;

error = vn_rdwr(UIO_READ,

vp,

(caddr_t) addr,

lcp->datasize,

macho_offset + lcp->dataoff,

UIO_SYSSPACE,

0,

kauth_cred_get(),

&resid,

current_proc());

如果不存在则调用ubc_cs_blob_allocate分配一块内存,调用vn_rdwr把签名信息读取到新分配的内存里。

if (ubc_cs_blob_add(vp,

ip_platform,

cputype,

cpusubtype,

macho_offset,

&addr,

datasize,

imgp,

0,

&blob))

调用ubc_cs_blob_add把csblob加入到链表中。

int

ubc_cs_blob_add(

struct vnode    *vp,

uint32_t        platform,

cpu_type_t      cputype,

cpu_subtype_t   cpusubtype,

off_t           base_offset,

vm_address_t    *addr,

vm_size_t       size,

struct image_params *imgp,

__unused int    flags,

struct cs_blob  **ret_blob)

{

error = cs_blob_init_validated(addr, size, &tmp_blob, &cd);

首先验证签名信息的格式是否正确,这里的校验并不完全严格,请读者自行阅读。

blob_ro = zalloc_ro(ZONE_ID_CS_BLOB, Z_WAITOK | Z_NOFAIL);

tmp_blob.csb_ro_addr = blob_ro;

tmp_blob.csb_vnode = vp;

/* AMFI needs to see the current blob state at the RO address. */

zalloc_ro_update_elem(ZONE_ID_CS_BLOB, blob_ro, &tmp_blob);

注意csblob结构体使用zlloc的接口将其信息通过PPL保存在只读内存区,请参考后面关于PPL的分析部分。

error = mac_vnode_check_signature(vp, &tmp_blob, imgp, &cs_flags, &signer_type, flags, platform);

}

mac_vnode_check_signature继续调用AMFI内核模块的接口,苹果公司的签名核心技术都存放于这个内核模块中,由于不会开源,我们将在下一章使用逆向过程技术还原出它所有的核心逻辑。

当load_code_signature返回成功后,则会调用cs_validate_range对所有的文件hash做对比测试,确保当前计算出的hash与文件加载进来的hash匹配。

注意:即使vnode中已经存在csblob信息,它只是不在走AMFI的流程,对所有文件的hash对比是每次都要进行的!因为保存在磁盘的时间,应用程序可能已经被窜改。

进程在启动时ios已经做了一次签名验证,但是在进程运行的过程中,代码和数据还是可能被篡改掉的,那么如何在进程的运行过程中进行签名的验证呢?它的验签逻辑可以发生在进程调度、系统调用过程、page fault甚至可以开一个单独的线程每隔一定时间进行轮询验签,但是作为一个工业级的os,需要考虑性能功耗的问题。ios选择了在page fault中做代码的hash值对比操作。

引起Page fault的原因有很多种,有发生在内核空间中的,有发生在用户空间中的,比如应用程序越界访问内核、应用程序对只读内存进行写操作,还有应用程序访问自身一段还没有被映射的页面,这个错误可以引发Copy on write动作或者这个页面之前被交换到磁盘上,那么在页面换回时,势必要再进行一次签名验证。

在进行异常处理前,需要先判断一下引起这个fault的物理页是否需要做一次签名验证,因为如果这块物理页已经被污染过,那么起始没必要进行fault处理了。如果没被污染, ios也有一些优化可以快速避开本次验签过程。vm_fault_cs_check_violation函数就是用来做这些事情。

vm_fault_cs_check_violation(

bool cs_bypass,

vm_object_t object,

vm_page_t m,

pmap_t pmap,

vm_prot_t prot,

vm_prot_t caller_prot,

vm_map_size_t fault_page_size,

vm_map_offset_t fault_phys_offset,

vm_object_fault_info_t fault_info,

bool map_is_switched,

bool map_is_switch_protected,

bool *cs_violation)

{

if (!cs_bypass &&

vm_fault_cs_need_validation(pmap, m, object,

fault_page_size, fault_phys_offset)) {

vm_object_lock_assert_exclusive(object);

if (VMP_CS_VALIDATED(m, fault_page_size, fault_phys_offset)) {

vm_cs_revalidates++;

}

vm_page_validate_cs(m, fault_page_size, fault_phys_offset);

}

}

vm_fault_cs_need_validation用来判断这个物理页是否需要进行验签过程。

staticbool

vm_fault_cs_need_validation(

pmap_t pmap,

vm_page_t page,

vm_object_t page_obj,

vm_map_size_t fault_page_size,

vm_map_offset_t fault_phys_offset)

{

if (pmap == kernel_pmap) {

/* 1 - not user space */

return false;

}

验签只针对用户态代码和数据。

if (!page_obj->code_signed) {

/* 3 - page does not belong to a code-signed object */

return false;

}

if (fault_page_size == PAGE_SIZE) {

/* looking at the whole page */

if (page->vmp_cs_tainted == VMP_CS_ALL_TRUE) {

/* 2 - page is all tainted */

return false;

}

如果这个物理页已经被污染掉,此次就不在需要再判断了。

if (page->vmp_cs_validated == VMP_CS_ALL_TRUE &&

!page->vmp_wpmapped) {

/* 4 - already fully validated and never mapped writable */

return false;

}

如果这个物理页此前已经被处理过,那么此次fault也不会再判断了。Ios的jit签名就是利用了这一点绕过了签名的验证。

} else {

/* looking at a specific sub-page */

if (VMP_CS_TAINTED(page, fault_page_size, fault_phys_offset)) {

/* 2 - sub-page was already marked as tainted */

return false;

}

if (VMP_CS_VALIDATED(page, fault_page_size, fault_phys_offset) &&

!page->vmp_wpmapped) {

/* 4 - already validated and never mapped writable */

return false;

}

}

/* page needs to be validated */

return true;

}

void

vm_page_validate_cs(

vm_page_t       page,

vm_map_size_t   fault_page_size,

vm_map_offset_t fault_phys_offset)

{

vm_object_t             object;

object = VM_PAGE_OBJECT(page);

vm_object_lock_assert_held(object);

if (vm_page_validate_cs_fast(page, fault_page_size, fault_phys_offset)) {

return;

}

vm_page_map_and_validate_cs(object, page);

}

staticboolean_t

vm_page_validate_cs_fast(

vm_page_t       page,

vm_map_size_t   fault_page_size,

vm_map_offset_t fault_phys_offset)

{

vm_object_t     object;

object = VM_PAGE_OBJECT(page);

vm_object_lock_assert_held(object);

if (page->vmp_wpmapped&&

!VMP_CS_TAINTED(page, fault_page_size, fault_phys_offset)) {

/*

* This page was mapped for "write" access sometime in the

* past and could still be modifiable in the future.

* Consider it tainted.

* [ If the page was already found to be "tainted", no

* need to re-validate. ]

*/

vm_object_lock_assert_exclusive(object);

VMP_CS_SET_VALIDATED(page, fault_page_size, fault_phys_offset, TRUE);

VMP_CS_SET_TAINTED(page, fault_page_size, fault_phys_offset, TRUE);

if (cs_debug) {

printf("CODESIGNING: %s: "

"page %p obj %p off 0x%llx "

"was modified\n",

__FUNCTION__,

page, object, page->vmp_offset);

}

vm_cs_validated_dirtied++;

}

if (VMP_CS_VALIDATED(page, fault_page_size, fault_phys_offset) ||

VMP_CS_TAINTED(page, fault_page_size, fault_phys_offset)) {

return TRUE;

}

}

vm_page_validate_cs_fast有个特殊的处理,如果page->vmp_wpmapped被设置,说明这个物理页在之前的某段时间里被设置为可写状态,xnu认为在将来的一段时间这个可写状态会一直保持,所以直接将这个物理页标记为污染和审计过,直接返回。

vm_page_map_and_validate_cs函数则对这个物理页做hash对比操作,读者可自行阅读相关代码。

接下来就要分析页面从磁盘交换回内存时的签名验证过程:

Osfmk/vm/vm_fault.c

vm_fault_page->memory_object_data_request

Osfmk/vm/memory_object.c

kern_return_t

memory_object_data_request

(

memory_object_t memory_object,

memory_object_offset_t offset,

memory_object_cluster_size_t length,

vm_prot_t desired_access,

memory_object_fault_info_t fault_info

)

{

return (memory_object->mo_pager_ops->memory_object_data_request)(

memory_object,

offset,

length,

desired_access,

fault_info);

}

xnu提供了几种不同的内存后备存储方式,比如swap交换文件、普通文件、内存压缩、 apple特有的内存加密方式,这些后备存储都对应不同的分页器,但只有几种后备存储才会在内存交换回来时做签名验证, 这里我们只以4k形式的分页器进行分析。

Osfmk/vm/vm_fourk_pager.c

const struct memory_object_pager_ops fourk_pager_ops = {

.memory_object_reference = fourk_pager_reference,

.memory_object_deallocate = fourk_pager_deallocate,

.memory_object_init = fourk_pager_init,

.memory_object_terminate = fourk_pager_terminate,

.memory_object_data_request = fourk_pager_data_request,

.memory_object_data_return = fourk_pager_data_return,

.memory_object_data_initialize = fourk_pager_data_initialize,

.memory_object_data_unlock = fourk_pager_data_unlock,

.memory_object_synchronize = fourk_pager_synchronize,

.memory_object_map = fourk_pager_map,

.memory_object_last_unmap = fourk_pager_last_unmap,

.memory_object_data_reclaim = NULL,

.memory_object_backing_object = NULL,

.memory_object_pager_name = "fourk_pager"

};

fourk_pager_data_request(

memory_object_t         mem_obj,

memory_object_offset_t  offset,

memory_object_cluster_size_t            length,

vm_prot_t               protection_required,

memory_object_fault_info_t mo_fault_info)

{

subpg_validated = FALSE;

subpg_tainted = 0;

if (src_page_object->code_signed) {

vm_page_validate_cs_mapped_chunk(

src_page,

(const void *) src_vaddr,

offset_in_src_page,

FOURK_PAGE_SIZE,

&subpg_validated,

&subpg_tainted);

num_subpg_signed++;

if (subpg_validated) {

num_subpg_validated++;

}

if (subpg_tainted & CS_VALIDATE_TAINTED) {

num_subpg_tainted++;

}

if (subpg_tainted & CS_VALIDATE_NX) {

/* subpg should not be executable */

if (sub_page_cnt > 1) {

} else {

num_subpg_nx++;

}

}

}

vm_page_validate_cs_mapped_chunk对一块物理内存进行签名验证,因为在页面被交换到磁盘的这段时间内,可能会被篡改掉。

此外在进行一个物理页面的复制时,也需要对源物理页进行签名验证。

osfmk\vm\vm_resident.c

void

vm_page_copy(

vm_page_t       src_m,

vm_page_t       dest_m)

{

vm_object_t     src_m_object;

src_m_object = VM_PAGE_OBJECT(src_m);

vm_object_lock_assert_held(src_m_object);

if (src_m_object != VM_OBJECT_NULL &&

src_m_object->code_signed) {

vm_page_copy_cs_validations++;

vm_page_validate_cs(src_m, PAGE_SIZE, 0);

}

dest_m->vmp_cs_tainted = src_m->vmp_cs_tainted;

dest_m->vmp_cs_nx = src_m->vmp_cs_nx;

if (dest_m->vmp_cs_tainted) {

vm_page_copy_cs_tainted++;

}

dest_m->vmp_error = src_m->vmp_error; /* sliding src_m might have failed... */

pmap_copy_page(VM_PAGE_GET_PHYS_PAGE(src_m), VM_PAGE_GET_PHYS_PAGE(dest_m));

}

Src_m代表源页面,如果它对应的object对象有code_signed标志,那么就会进行一次签名验证,页面拷贝需要确保它的完整性。

对于只读rootfs上的文件,xnu做了优化,在page fault第一次验证完签名后,如果当前进程没有试图将只读rootfs挂载为可写,那么后续就不再做签名验证,属于性能优化的一部分。

Bsd/sys/ubc_internal.h

struct ubc_info {

struct  cs_blob         * cs_blobs; /* for CODE SIGNING */

struct  cs_blob         * cs_blob_supplement;/* supplemental blob (note that there can only be one supplement) */

void                    * XNU_PTRAUTH_SIGNED_PTR("ubc_info.cs_valid_bitmap") cs_valid_bitmap;     /* right now: used only for signed files on the read-only root volume */

uint64_t                cs_valid_bitmap_size;

}

Ubc_info结构体除了保存struct cs_blob结构体外,还可选的保存了一个bitmap,它用来设置一个物理页的签名状态。

Osfmk/vm/vm_protos.h

[#define] CS_BITMAP_SET1//对页面设置为已经检查过

[#define] CS_BITMAP_CLEAR 2// 清除签名状态

[#define] CS_BITMAP_CHECK 3// 对页面进行签名检查

vm_page_validate_cs_fast函数前面讲过它会进行预判此次page fault是否需要验证这个页面的签名。

staticboolean_t

vm_page_validate_cs_fast(

vm_page_t       page,

vm_map_size_t   fault_page_size,

vm_map_offset_t fault_phys_offset)

{

kern_return_t kr;

kr = vnode_pager_cs_check_validation_bitmap(

object->pager,

page->vmp_offset + object->paging_offset,

CS_BITMAP_CHECK);

if (kr == KERN_SUCCESS) {

page->vmp_cs_validated = VMP_CS_ALL_TRUE;

page->vmp_cs_tainted = VMP_CS_ALL_FALSE;

vm_cs_bitmap_validated++;

return TRUE;

}

它会调用vnode_pager_cs_check_validation_bitmap传递CS_BITMAP_CHECK进行判断是否需要签名验证。

vnode_pager_cs_check_validation_bitmap进一步调用ubc_cs_check_validation_bitmap。

kern_return_t

ubc_cs_check_validation_bitmap(

vnode_t                 vp,

memory_object_offset_t          offset,

int                     optype)

{

kern_return_t   kr = KERN_SUCCESS;

if (!USE_CODE_SIGN_BITMAP(vp)|| !UBCINFOEXISTS(vp)) {              【1】

kr = KERN_INVALID_ARGUMENT;

} else {

struct ubc_info *uip = vp->v_ubcinfo;

char            *target_bitmap = uip->cs_valid_bitmap;

if (target_bitmap == NULL) {

kr = KERN_INVALID_ARGUMENT;

} else {

uint64_t        bit, byte;

bit = atop_64( offset );

byte = bit >> 3;

if (byte > uip->cs_valid_bitmap_size) {

kr = KERN_INVALID_ARGUMENT;

} else {

if (optype == CS_BITMAP_SET) {

target_bitmap[byte] |= (1 << (bit & 07));

kr = KERN_SUCCESS;

} else if (optype == CS_BITMAP_CLEAR) {

target_bitmap[byte] &= ~(1 << (bit & 07));

kr = KERN_SUCCESS;

} else if (optype == CS_BITMAP_CHECK) {

if (target_bitmap[byte] & (1 << (bit & 07))) {           【2】

kr = KERN_SUCCESS;

} else {

kr = KERN_FAILURE;

}

}

}

}

}

return kr;

}

#define USE_CODE_SIGN_BITMAP(vp) ( (vp != NULL) && (vp->v_mount != NULL) && (vp->v_mount->mnt_flag & MNT_ROOTFS) && !root_fs_upgrade_try)
USE_CODE_SIGN_BITMAP这个首先宏判断vnode是不是rootfs,并且要判断root_fs_upgrade_try是否为0。这个变量代表的是进程试图将只读的文件系统挂载为可写。

boolean_t root_fs_upgrade_try = FALSE;

int

__mac_mount(struct proc *p, register struct __mac_mount_args *uap, __unused int32_t *retval)

{

if ((flags & MNT_RDONLY) == 0) {

root_fs_upgrade_try = TRUE;

}

}

所以【1】处的逻辑为:如果vnode属于rootfs,并且root_fs_upgrade_try设置为了1,说明有进程将只读rootfs重新挂载为可写,那么就必须对这个物理页进行签名验证,否则在【2】处要进行一次页面曾经是否被检测过的判断,如果对应的比特位已经被设置,则无需进行签名验证,否则需要进行签名验证。我们看到CS_BITMAP_CHECK是用来判断比特位是否设置的,那么CS_BITMAP_SET是在什么时候调用的呢?答案在vm_page_validate_cs_mapped_slow中。

void

vm_page_validate_cs_mapped_slow(

vm_page_t       page,

const void      *kaddr)

{

vm_object_t             object;

memory_object_offset_t  mo_offset;

memory_object_t         pager;

struct vnode            *vnode;

int                     validated, tainted, nx;

assert(page->vmp_busy);

object = VM_PAGE_OBJECT(page);

vm_object_lock_assert_exclusive(object);

vm_cs_validates++;

pager = object->pager;

assert(object->paging_in_progress);

vnode = vnode_pager_lookup_vnode(pager);

mo_offset = page->vmp_offset + object->paging_offset;

/* verify the SHA1 hash for this page */

validated = 0;

tainted = 0;

nx = 0;

cs_validate_page(vnode,

pager,

mo_offset,

(const void *)((const char *)kaddr),

&validated,

&tainted,

&nx);

page->vmp_cs_validated |= validated;

page->vmp_cs_tainted |= tainted;

page->vmp_cs_nx |= nx;

if (page->vmp_cs_validated == VMP_CS_ALL_TRUE &&

page->vmp_cs_tainted == VMP_CS_ALL_FALSE) {

vnode_pager_cs_check_validation_bitmap(object->pager,

mo_offset,

CS_BITMAP_SET);

}

}

cs_validate_page对物理页进行hash值验证,如果合法,则调用vnode_pager_cs_check_validation_bitmap传递CS_BITMAP_SET对相应比特位进行了设置。此后ubc_cs_check_validation_bitmap发现如果页面比特位已经被设置,后面就无需再进行签名验证了。

在进程正常退出时,xnu是不会做签名验证的,只有在异常退出时,且有以下几种情况就会必须验证签名:当进程收到coredump或crash report信号时,或者因进程签名验证失败收到CS_KILLED信号时。

Bsd/kern/kern_exit.c

void

proc_prepareexit(proc_t p, int rv, boolean_t perf_notify)

{

/*

* Generate a corefile/crashlog if:

*     The process doesn't have an exit reason that indicates no crash report should be created

*     AND any of the following are true:

*     - The process was terminated due to a fatal signal that generates a core

*     - The process was killed due to a code signing violation

*     - The process has an exit reason that indicates we should generate a crash report

*

* The first condition is necessary because abort_with_reason()/payload() use SIGABRT

* (which normally triggers a core) but may indicate that no crash report should be created.

*/

if (!(PROC_HAS_EXITREASON(p) && (PROC_EXITREASON_FLAGS(p) & OS_REASON_FLAG_NO_CRASH_REPORT)) &&

(hassigprop(WTERMSIG(rv), SA_CORE) || ((proc_getcsflags(p) & CS_KILLED) != 0) ||

(PROC_HAS_EXITREASON(p) && (PROC_EXITREASON_FLAGS(p) &

OS_REASON_FLAG_GENERATE_CRASH_REPORT)))) {

task_t task = proc_task(p);

uintptr_t bt[2];

struct backtrace_user_info btinfo = BTUINFO_INIT;

unsigned int frame_count = backtrace_user(bt, 2, NULL, &btinfo);            [1]

int bt_err = btinfo.btui_error;

if (bt_err == 0 && frame_count >= 1) {

/*

* First check at the page containing the current PC.

* This passes if the page code signs -or- if we can't figure out

* what is at that address. The latter action is so we continue checking

* previous pages which may be corrupt and caused a wild branch.

*/

kr = revalidate_text_page(task,bt[0]);                               [2]

/* No corruption found, check the previous sequential page */

if (kr == KERN_SUCCESS) {

kr = revalidate_text_page(task,bt[0] - get_task_page_size(task));     [3]

}

/* Still no corruption found, check the current function's caller */

if (kr == KERN_SUCCESS) {

if (frame_count > 1 &&

atop(bt[0]) != atop(bt[1]) &&           /* don't recheck PC page */

atop(bt[0]) - 1 != atop(bt[1])) {       /* don't recheck page before */

kr = revalidate_text_page(task, (vm_map_offset_t)bt[1]);       [4]

}

}

if (kr != KERN_SUCCESS) {

os_log(OS_LOG_DEFAULT,

"Text page corruption detected in dying process %d\n", proc_getpid(p));

}

}

}

在[1]处先获取当前函数栈的backtrace信息,bt[0]代表当前的PC指针,bt[1]代表当前函数caller的地址。在[2]处调用revalidate_text_page对当前pc所在的物理页进行一次签名检查,如果没有问题,则在[3]处对当前pc地址所在的前一个物理页进行签名验证,没有还是没有问题,就在对函数的caller地址所在的物理页进行签名检测。我们看到这一系列操作只是试图检测当前pc附近的代码段有没有被破坏。

Osfmk/vm/vm_fault.c

kern_return_t

revalidate_text_page(task_t task, vm_map_offset_t code_addr)

{

kern_return_t          kr;

vm_map_t               map;

vm_object_t            object = NULL;

vm_object_offset_t     offset;

vm_page_t              page = NULL;

struct vnode           *vnode;

uint64_t               *diagnose_buffer = NULL;

CA_EVENT_TYPE(vmtc_telemetry) * event = NULL;

ca_event_t ca_event = NULL;

map = task->map;

if (task->map == NULL) {

return KERN_SUCCESS;

}

kr = vmtc_revalidate_lookup(map, code_addr, &object, &offset, &page);              [1]

if (kr != KERN_SUCCESS) {

goto done;

}

/*

* The object needs to have a pager.

*/

if (object->pager == NULL) {

goto done;

}

/*

* Needs to be a vnode backed page to have a signature.

*/

vnode = vnode_pager_lookup_vnode(object->pager);

if (vnode == NULL) {

goto done;

}

/*

* Object checks to see if we should proceed.

*/

if (!object->code_signed ||     /* no code signature to check */

object->internal ||         /* internal objects aren't signed */

object->terminating ||      /* the object and its pages are already going away */

!object->pager_ready) {     /* this should happen, but check shouldn't hurt */

goto done;

}

/*

* Check the code signature of the page in question.

*/

vm_page_map_and_validate_cs(object, page);                              [2]

/*

* At this point:

* vmp_cs_validated |= validated (set if a code signature exists)

* vmp_cs_tainted |= tainted (set if code signature violation)

* vmp_cs_nx |= nx;  ??

*

* if vmp_pmapped then have to pmap_disconnect..

* other flags to check on object or page?

*/

if (page->vmp_cs_tainted != VMP_CS_ALL_FALSE) {                            [3]

/*

* On development builds, a boot-arg can be used to cause

* a panic, instead of a quiet repair.

*/

if (vmtc_panic_instead) {

panic("Text page corruption detected: vm_page_t 0x%llx", (long long)(uintptr_t)page);

}

/*

* We're going to invalidate this page. Grab a copy of it for comparison.

*/

ca_event = CA_EVENT_ALLOCATE(vmtc_telemetry);

event = ca_event->data;

diagnose_buffer = vmtc_text_page_diagnose_setup(code_addr, page, event);

/*

* Invalidate, i.e. toss, the corrupted page.

*/

if (!page->vmp_cleaning &&

!page->vmp_laundry &&

!page->vmp_fictitious &&

!page->vmp_precious &&

!page->vmp_absent &&

!page->vmp_error &&

!page->vmp_dirty &&

!is_page_wired(page)) {

if (page->vmp_pmapped) {

int refmod = pmap_disconnect(VM_PAGE_GET_PHYS_PAGE(page));

if (refmod & VM_MEM_MODIFIED) {

SET_PAGE_DIRTY(page, FALSE);

}

if (refmod & VM_MEM_REFERENCED) {

page->vmp_reference = TRUE;

}

}

/* If the page seems intentionally modified, don't trash it. */

if (!page->vmp_dirty) {

VM_PAGE_FREE(page);

} else {

event->vmtc_not_eligible = true;

}

} else {

event->vmtc_not_eligible = true;

}

vm_object_unlock(object);

object = VM_OBJECT_NULL;

/*

* Now try to diagnose the type of failure by faulting

* in a new copy and diff'ing it with what we saved.

*/

if (diagnose_buffer != NULL) {

vmtc_text_page_diagnose(code_addr, diagnose_buffer, event);

}

if (corruption_test_va != 0) {

corruption_test_va = 0;

event->vmtc_testing = true;

}

kernel_triage_record(thread_tid(current_thread()),

KDBG_TRIAGE_EVENTID(KDBG_TRIAGE_SUBSYS_VM, KDBG_TRIAGE_RESERVED, KDBG_TRIAGE_VM_TEXT_CORRUPTION),

0 /* arg */);

CA_EVENT_SEND(ca_event);

printf("Text page corruption detected for pid %d\n", proc_selfpid());

++vmtc_total;

return KERN_FAILURE;

}

done:

if (object != NULL) {

vm_object_unlock(object);

}

return KERN_SUCCESS;

}

在[1]处获取addr对应的object和page信息,在[2]处调用vm_page_map_and_validate_cs来对这个page进行签名验证,在[3]处如果检测到签名失败,还要进行详细的信息获取,比如要对比这个page是哪一块内存出现了问题。

Amfi(Apple Mobile File Integrity)是一个内核扩展, IOS的代码验签的过程都集中在这个模块中,本文以ios14为例来剖析ios的代码验签过程。

3.2.1 vnode_check_signature

MAC系统通过以下代码进入到amfi流程中:

int

mac_vnode_check_signature(struct vnode *vp, struct cs_blob *cs_blob,

struct image_params *imgp,

unsigned int *cs_flags, unsigned int *signer_type,

int flags, unsigned int platform) {

MAC_CHECK(vnode_check_signature, vp, vp->v_label, cpu_type, cs_blob,

cs_flags, signer_type, flags, platform, &fatal_failure_desc, &fatal_failure_desc_len);

}

__ZL22_vnode_check_signatureP5vnodeP5labeliP7cs_blobPjS5_ijPPcPm

MOV W0, #1048 ; size

BL _IOMalloc_external

CBZ X0, loc_FFFFFFF008308F44

MOV X22, X0 ; unkown_struct;

LDP X25, X26, [X29,#arg_0]

ADD X0, X0, #8 ; __dst

MOV X27, X22

MOVK X27, #0x6712,LSL#48

ADRL X8, off_FFFFFFF0077AE4F0

PACDA X8, X27

STR X8, [X22] ; *(unkown_struct + 0) = pacda()

ADRL X1, l_.str.82 ; __src

MOV W2, #1024 ; __n

BL _memmove ; memmove(unkown_struct + 8, src, 1024);

STRB WZR, [X22,#1032] ; *(unkown_struct + 1032) = 0

ADRL X8, off_FFFFFFF0077AE4C0

PACDA X8, X27

STR X8, [X22]

STR X24, [X22,#1040] ; *(unkown_struct + 1040) = vnode

MOV X0, X22

MOV X1, X23

MOV X2, X21

MOV X3, X20

MOV X4, X19

MOV W5, #0

MOV X6, X25

MOV X7, X26 ; (unkown_struct, csblob, cs_flags, signer_type, flags, 0, *addr1, *addr2)

BL__ZN20StaticPlatformPolicyILb1ELb1ELb0ELb0ELb0ELb0ELb1ELb1ELb0ELb1ELb0ELb0ELb0ELb0ELb1ELb1ELj2ELb1ELb0EE15check_signatureEP8LazyPathiP7cs_blobPjS5_ibbPPcPm

进一步调用check_signature函数,从上面的代码中,我们可以推测它的参数结构为:

check_signature(unkown_struct, csblob, cs_flags, signer_type, flags, 0, *addr1, *addr2)。
3.2.2 check_signature

// (unkown_struct, csblob, cs_flags, signer_type, flags, 0, *addr1, *addr2)

__int64 __fastcall StaticPlatformPolicy<true,true,false,false,false,false,true,true,false,true,false,false,false,false,true,true,2u,true,false>::check_signature(

LazyPath *a1,

__int64 a2,

unsigned int *a3,

_DWORD *a4,

unsigned int a5,

__int64 a6,

char **a7,

unsigned __int64 *a8)

{

if ( (StaticPlatformPolicy<true,true,false,false,false,false,true,true,false,true,false,false,false,false,true,true,2u,true,false>::loadEntitlementsFromSignature(

&inColl,

a2,

&v114) & 1) == 0 )

{

v30 = fatal_error_fmt(

a1,

a7,

a8,

"The signature could not be validated because AMFI could not load its entitlements for validation: %s",

v114);

v31 = 0LL;

v32 = 1LL;

v16 = inColl;

if ( !inColl )

goto LABEL_20;

goto LABEL_19;

}

loadEntitlementsFromSignature函数的作用是从struct cs_blob中获取进程的entitlements,它的大小在8byte到128m之间。如果cs_blob存储的cd hash在static trustcache或loaded trustcache中,那么会在entitlements中加入一个新节点platform-application,如果cs_blob存取的identifier为空,则在entitlements中删除节点com.apple.private.signing-identifier,否则设置为cs_blob对应的identifier。

...

if ( v23 && (v24 = (const char *)((__int64 (*)(void))v23->__vftable[1].isEqualTo)()) != 0LL )

{

v25 = (OSDictionary *)v24;

*a3 |= 0x200u;                     // cs_flags |= CS_KILL

if ( !strcmp(v24, "get-task-allow") )

{

LOBYTE(v126[0]) = 0;

if ( !(unsigned int)AppleMobileFileIntegrity::AMFIEntitlementGetBool(

(AppleMobileFileIntegrity *)v16,

v25,

(const char *)v126,

v26)

&& LOBYTE(v126[0]) != 0 )

{

*a3 |= 4u;                      // CS_GET_TASK_ALLOW

}

}

}

...

获取entitlements后,首先将第三个参数cs_flags加上CS_KILL标志。如果entitlements包含get-task-allow节点,则再把CS_GET_TASK_ALLOW标志加入到cs_flags中。

cdhash = (const unsigned __int8 *)csblob_get_cdhash(v13);

if ( !cdhash )

{

v30 = fatal_error_fmt(a1, a7, a8, "Internal Error: No cdhash found.");

goto LABEL_37;

}

接着获取进程的cd hash,如果不存在直接返回。

if ( (AMFIIsCodeDirectoryInTrustCache(cdhash) & 1) == 0 && !(unsigned int)codeDirectoryHashIsInLoadedTrustCache(v37) )

{

}

如果cd hash在static trustcache或loaded trustcache里。

v39 = postValidation(a1, v13, v38, "in-kernel", a7, a8);

v30 = IsCDHashBlacklisted(v37);

if ( (_DWORD)v30 )

{

v30 = fatal_error_fmt(a1, a7, a8, "Bad things happened.");

LABEL_37:

v31 = 0LL;

goto LABEL_82;

}

postValidation函数判断cs_flags是否包含CS_PLATFORM_BINARY,如果是返回1。否则继续判断hash type是否为sha256,如果是返回1,其余返回0。

Ios还为cd hash设置了一个黑名单,IsCDHashBlacklisted函数判断一个cd hash是否在黑名单中。

*a3 |= 0x20000000u;// CS_SIGNED

最后将CS_SIGNED标志放入到cs_flags中,函数返回。

我们看到如果一个cd hash在static trustcache或者在loaded trustcache里,则直接完成此次判断,接下来继续分析不在trustcache里的情况。

if ( _codeDirectoryHashInCompilationServiceHash(v37) && (unsigned int)noEntitlementsPresent(v13) )

{

LOBYTE(v126[0]) = 0;

v41 = current_proc();

AppleMobileFileIntegrity::AMFIEntitlementGetBool(

v41,

(proc *)"com.apple.private.amfi.can-execute-cdhash",

(const char *)v126,

v42);

if ( LOBYTE(v126[0]) )

{

v30 = postValidation(a1, v13, *a3, "can-execute-cdhash", a7, a8);

v40 = v30 ^ 1;                         // 非(platform binary并且hash type为sha256)

}

else

{

IOLog("AMFI: can-execute-cdhash code in non-entitled context.\n");

v40 = 1;

}

v31 = 0LL;

goto LABEL_81;

}

首先判断这个cd hash如果在compilationServiceHash里,并且进程所含的entitlements不为空,如果进程的entitlements包含com.apple.private.amfi.can-execute-cdhash,并且这个进程并非platform binary,则完成此次判断直接返回。compilationServiceHash由用户态进程调用AMFI loadCompilationServiceCodeDirectoryHash接口进行设置,请参考3.3节。

addr = (unsigned int *)csblob_get_addr(v112);

size = csblob_get_size(v112);

blob_bytes = csblob_find_blob_bytes(addr, size, 0, 0xFADE0C02);// CSMAGIC_CODEDIRECTORY

if ( !blob_bytes )

{

printf("AMFI: '%s' has no cd?\n", v48);

v123[1] = 0LL;

LABEL_63:

printf("AMFI: '%s': Unrecoverable CT signature issue, bailing out.\n");

goto LABEL_79;

}

接着搜索cs_blob结构是否包含CSMAGIC_CODEDIRECTORY,如果不存在则直接返回。

v52 = (__int64)blob_bytes;

v108 = a1;

v53 = bswap32(blob_bytes[1]);               // CS_GenericBlob.length

if ( v53 <= 7 )

{

printf("AMFI: '%s' has short cd (%u)?\n");

LABEL_62:

v123[1] = 0LL;

goto LABEL_63;

}

CODEDIRECTORY结构不能小于7。

v54 = (unsigned int *)csblob_get_addr(v112);

v55 = csblob_get_size(v112);

v56 = csblob_find_blob_bytes(v54, v55, 0x10000, 0xFADE0B01);// CSMAGIC_BLOBWRAPPER  CMS Signature

if ( !v56 )

{

printf("AMFI: '%s' has no CMS blob?\n");

goto LABEL_62;

}

继续搜索cs_blob是否包含CSMAGIC_BLOBWRAPPER,它会携带证书信息。

if ( v58 <= 7 )                             // CS_GenericBlob.length

{

printf("AMFI: '%s' has short cms (%u), bailing out.\n");

goto LABEL_62;

}

Cms结构不能小于7。

if ( v57 == 0x8000000 )                     // CS_GenericBlob.length == 0

{

if ( (unsigned int)CTEvaluateAMFICodeSignatureCMS(

v59,

v100,

v52,

v53,

v60,

0LL,

0LL,

(__int64 *)&v123[1],

&v117,

&v116,

v123,

(__int64)&v122) )

{

v123[1] = 0LL;

printf("AMFI: '%s' does not pass CT evaluation, result: %#x\n");

goto LABEL_63;

}

}

CTEvaluateAMFICodeSignatureCMS函数验证cms携带的证书是否由苹果公司签发。

if ( (_DWORD)v116 )

{

hashtype = csblob_get_hashtype(v112);

v70 = (const unsigned __int8 *)v123[0];

if ( (_DWORD)v116 == 1 )

{

v71 = 1;

v61 = v108;

}

else

{

v61 = v108;

if ( (_DWORD)v116 != 4 )

{

printf("AMFI: '%s' has unknown CT digest type %#x\n");

goto LABEL_149;

}

v71 = 2;

}

if ( v71 == hashtype )

{

if ( v122 > 19 )

{

if ( !memcmp(v46, v123[0], 0x14uLL) )

goto LABEL_70;

*(_QWORD *)&v94 = 0xAAAAAAAAAAAAAAAALL;

*((_QWORD *)&v94 + 1) = 0xAAAAAAAAAAAAAAAALL;

*(_OWORD *)&v125[25] = v94;

*(_OWORD *)v125 = v94;

*(_OWORD *)&v125[16] = v94;

*(_OWORD *)&v127[9] = v94;

*(_OWORD *)v126 = v94;

*(_OWORD *)v127 = v94;

cdhash_to_string(v125, v46);

cdhash_to_string((char *)v126, v70);

printf("AMFI: '%s': cdhash mismatch: actual '%s' != expected '%s'\n");

}

else

{

printf("AMFI: '%s' has unexpected digest data len %zu (type %#x)\n");

}

}

else

{

printf("AMFI: '%s' has unexpected digest type, actual %#x != expected %#x\n");

}

LABEL_149:

printf("AMFI: '%s': V2 hash agility validation failed, bailing out.\n");

goto LABEL_63;

}

如果v116不为空,还要判断CTEvaluateAMFICodeSignatureCMS返回的cd hash值是否与当前csblob的cd hash值是否相同,不相同则验证失败返回。

LABEL_70:

if ( ((unsigned __int64)v123[1] & 0x1FF80) == 0 )

{

printf("AMFI: '%s': unsuitable CT policy %#llx for this platform/device, rejecting signature.\n");

goto LABEL_79;

}

v123[1]是CTEvaluateAMFICodeSignatureCMS返回的某个标志值。

if ( ((__int64)v123[1] & 0x5100) != 0 && allow3rdParty && !IsCDHashBlacklisted(v46))

{

IOLog("App Store Fast Path -> %s\n", v48);

v64 = *a3 | 0x4000;                    // CS_ENTITLEMENTS_VALIDATED

*a3 = v64;

v15 = v107;

v65 = v103;

v63 = v105;

goto LABEL_123;

}

*a3 |= 0x20000000u; // CS_SIGNED

0x5100代表app由应用市场签发,对cs_flags标志设置 CS_ENTITLEMENTS_VALIDATED|CS_SIGNED,然后直接返回。

可以看到ios对app应用也可以使能CDHashBlacklisted,这样可以将某个app的cd hash加入黑名单,就可以防止它运行。

if ( !allow3rdParty)

{

printf("AMFI: '%s' does not pass kernel-side policy for this model, bailing out.\n", v48);

v62 = 0;

v66 = 0;

v63 = v105;

LABEL_120:

if ( !(v66 | v62) )

{

if ( v102 && !v113 )

{

printf("AMFI: code signature validation failed.\n");

printf("AMFI: bailing out because of restricted entitlements.\n");

v30 = fatal_error_fmt(

v61,

v105,

v103,

"Code has restricted entitlements, but the validation of its code signature failed.\n"

"Unsatisfied Entitlements: %s",

v31);

goto LABEL_80;

}

LABEL_79:

v30 = printf("AMFI: code signature validation failed.\n");

LABEL_80:

v40 = 1;

v15 = v107;

goto LABEL_81;

}

if ( !v66 )

{

v30 = printf("AMFI: code signature validation failed.\n");

v15 = v107;

if ( v62 )

{

IOLog("AMFI: detected an anomaly during entitlement parsing.\n");

v30 = fatal_error_fmt(v61, v63, v103, "anomaly detecting during entitlement parsing\n");

}

v40 = 1;

goto LABEL_81;

}

v64 = *a3;

v15 = v107;

v65 = v103;

LABEL_123:

v30 = postValidation(v61, v112, v64, "dynamic", v63, v65);

v40 = v30 ^ 1;

goto LABEL_81;

}

如果内核配置为不允许加载三方应用,则打印一些出错信息,直接返回。

if ( (csblob_get_flags(v112) & 2) == 0 )  // CS_ADHOC

{

printf("AMFI: '%s' has zero length cms, but is not adhoc?\n");

goto LABEL_63;

}

printf("AMFI: '%s' is adhoc signed.\n", v48);

v61 = v108;

如果允许三方应用,则判断cs_flags是否为CS_ADHOC,不是的话则直接返回。

接下来要与用户态进程amfid交互,来判断CS_ADHOC进程是否合法。

if ( (unsigned int)getDaemonPort(v123) )

{

IOLog("StaticPlatformPolicy<%d>: no registered daemon port\n", 2LL);

v62 = 0;

v63 = v105;

LABEL_116:

v86 = 0;

LABEL_117:

if ( v62 )

v66 = 0;

else

v66 = v86;

goto LABEL_120;

}

获取afmid进程的port,mach微内核通过port进行进程间通讯。

v91 = verify_code_directory(

(__int64)v89,

(__int64)v61 + 8,

base_offset,

v110,

v88,

v113 != 0,

2LL,

v116,

v117,

(_DWORD *)&v118 + 1,

&v120,

&v119,

v109,

(_DWORD *)&v121 + 1,

&v121,

&v118,

v31,

(__int64)&v123[1],

v126);

调用verify_code_directory让用户态amfid去做校验。

if ( v92 == -308 )

{

IOLog("StaticPlatformPolicy<%d>: verify_code_directory server is dead\n");

}

else if ( v92 )

{

IOLog("StaticPlatformPolicy<%d>: verify_code_directory returned 0x%x\n");

}

当用户态amfid进程返回出错码,则直接返回。

*(_OWORD *)v125 = *(_OWORD *)v126;

*(_OWORD *)&v125[16] = *(_OWORD *)v127;

if ( (unsigned int)tokenIsTrusted((audit_token_t *)v125) )

{

v62 = v118 != 0;

if ( v120 == 1 )

{

if ( !memcmp(v68, &v123[1], 20uLL) )

{

if ( HIDWORD(v121) )

panic("\"amfid is broken. (%s) (%d) (%d) (%d)\"", (const char *)v61 + 8, v88, v120, HIDWORD(v121));

if ( (_DWORD)v121 )

*a3 |= 0x40000000u;             // CS_DEV_CODE

if ( v119 )

*a3 &= ~0x800u;                 // CS_RESTRICT

v87 = BYTE4(v118);

if ( HIDWORD(v118) )

{

v87 = 0;

*a3 |= 0x4200u;                 // CS_KILL|CS_ENTITLEMENTS_VALIDATED

}

v86 = 1;

LABEL_115:

v63 = v105;

if ( (v87 & 1) == 0 )

goto LABEL_117;

goto LABEL_116;

}

IOLog("%s: Possible race detected. Rejecting.\n", (const char *)v61 + 8);

IOLog("StaticPlatformPolicy<%d>: Unable to match identity\n", 2LL);

当用户态afmid返回成功时,会先调用tokenIsTrusted传递当前进程的audit_token,它根据audit_token找到当前进程的cd hash是否在static trustcache中,以此证明当前内核确实是与amfid进程通讯,同时amfid会返回给内核一个cd hash值,如果与当前进程的cd hash值相同,则验证通过。根据不同的返回值设置相应的cs_flags,然后返回。

AppleMobileFileIntegrityUserClient::externalMethod(unsigned int, IOExternalMethodArguments *, IOExternalMethodDispatch *, OSObject *, void *)::methods

DCQ __ZN34AppleMobileFileIntegrityUserClient14loadTrustCacheEP8OSObjectPvP25IOExternalMethodArguments

DCQ __ZN34AppleMobileFileIntegrityUserClient19flushAllValidationsEP8OSObjectPvP25IOExternalMethodArguments

DCQ __ZN34AppleMobileFileIntegrityUserClient39loadCompilationServiceCodeDirectoryHashEP8OSObjectPvP25IOExternalMethodArguments

DCQ __ZN34AppleMobileFileIntegrityUserClient20isCdhashInTrustCacheEP8OSObjectPvP25IOExternalMethodArguments

DCQ __ZN34AppleMobileFileIntegrityUserClient14loadTrustCacheEP8OSObjectPvP25IOExternalMethodArguments

DCQ __ZN34AppleMobileFileIntegrityUserClient17validateSignatureEP8OSObjectPvP25IOExternalMethodArguments

DCQ __ZN34AppleMobileFileIntegrityUserClient11setDenylistEP8OSObjectPvP25IOExternalMethodArguments

3.2.3.1 loadTrustCache

_int64 __fastcall AppleMobileFileIntegrityUserClient::loadTrustCache(

AppleMobileFileIntegrityUserClient *this,

OSObject *a2,

void *a3,

IOExternalMethodArguments *a4)

{

v6 = proc_selfpid();

IOLog(

"%s: PID %d is requesting a trust cache load\n",

"static IOReturn AppleMobileFileIntegrityUserClient::loadTrustCache(OSObject *, void *, IOExternalMethodArguments *)",

v6);

每次加载都产生一次日志。

Bool = AppleMobileFileIntegrity::AMFIEntitlementGetBool(

v9,

(proc *)"com.apple.private.amfi.can-load-trust-cache",

&v30,

v10);

proc_rele(v11);

if ( Bool )

{

proc_selfpid();

IOLog("%s: failure getting load trust cache entitlement for process %d\n");

return 3758097089LL;

}

if ( !v30 )

{

proc_selfpid();

IOLog("%s: process %d not allowed to load trust cache\n");

return 3758097089LL;

}

判断当前进程是否由com.apple.private.amfi.can-load-trust-cache这个entitlement。

v17 = *((unsigned int *)a3 + 1);

if ( (_DWORD)v17 == 7 )

{

V17代表trustcache类

原文链接:https://mp.weixin.qq.com/s?__biz=Mzg4NjU1NDU4MA==&mid=2247483872&idx=1&sn=167c757186931b3f09d7993c9d5d8677