原创 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类