#include "IGDispatch.h" #include "../resolve/IGResolve.h" #include "../anti_hook/IGAntiHook.h" #include "../primitives/IGInline.h" #include #include #include #include #include /* 编码只减少常量区明文,不作为秘密或强加密。缓存与基线仍可被同进程攻击者修改。 */ static const unsigned char kNames[2][5] = {{0x4b,0x4e,0x55,0x48,0x59}, {0x5f,0x50,0x53,0x4f,0x59}}; static pthread_once_t gOnce=PTHREAD_ONCE_INIT; static _Atomic(uintptr_t) gSlots[2]; static uintptr_t gExpected[2]; static unsigned char gPrefixes[2][16]; static IGStatus gInitialStatus[2]={IG_UNAVAILABLE,IG_UNAVAILABLE}; static _Thread_local int gResolving; #ifdef IG_OBSERVATION static _Atomic(uint64_t) gAttempted[2], gDispatched[2]; #define IG_COUNT(slot,index) atomic_fetch_add_explicit(&(slot)[index],1,memory_order_relaxed) #else #define IG_COUNT(slot,index) ((void)0) #endif static int read_prefix(uintptr_t address, unsigned char out[16]) { vm_size_t copied=0; return vm_read_overwrite(mach_task_self(),address,16,(vm_address_t)out,&copied)==KERN_SUCCESS && copied==16; } static void initialize(void) { for (unsigned i=0;i<2;i++) { IGResolveResult r=ig_resolve_verified(NULL,kNames[i],5,NULL,NULL); gInitialStatus[i]=r.status; if (r.status!=IG_CLEAR || !r.address) continue; uintptr_t address=(uintptr_t)r.address; if (!read_prefix(address,gPrefixes[i])) { gInitialStatus[i]=IG_UNAVAILABLE; continue; } gExpected[i]=address; atomic_store_explicit(&gSlots[i],address,memory_order_release); } } static int prepare(void) { /* dlsym/装载初始化过程中若重入受保护入口,拒绝而不是等待自身 once 锁。 */ if (gResolving) return 0; gResolving=1; int rc=pthread_once(&gOnce,initialize); gResolving=0; return rc==0; } static IGStatus validate(unsigned i, uintptr_t *address, int *reason) { if (gInitialStatus[i]!=IG_CLEAR) { *reason=IG_REASON_DISPATCH_UNAVAILABLE; return gInitialStatus[i]; } uintptr_t current=atomic_load_explicit(&gSlots[i],memory_order_acquire); if (!current || current!=gExpected[i]) { *reason=IG_REASON_DISPATCH_TAMPER; return IG_DETECTED; } IGStatus status=ig_verify_function((void *)current,"dispatch-target",NULL,NULL); if (status!=IG_CLEAR) { *reason=status==IG_DETECTED ? IG_REASON_INLINE_HOOK : IG_REASON_VERIFICATION_UNAVAILABLE; return status; } unsigned char bytes[16]; if (!read_prefix(current,bytes)) { *reason=IG_REASON_VERIFICATION_UNAVAILABLE; return IG_UNAVAILABLE; } if (ig_memcmp(bytes,gPrefixes[i],16)!=0) { *reason=IG_REASON_DISPATCH_TAMPER; return IG_DETECTED; } *address=current; return IG_CLEAR; } static uintptr_t checked_address(unsigned i) { if (!prepare()) { errno=EDEADLK; return 0; } uintptr_t address=0; int reason=0; IGStatus status=validate(i,&address,&reason); if (status!=IG_CLEAR) { errno=status==IG_DETECTED ? EACCES : ENOSYS; return 0; } return address; } __attribute__((used,noinline)) ssize_t IG_dispatch_write(int fd, const void *buffer, size_t count) { int incoming=errno; IG_COUNT(gAttempted,0); uintptr_t address=checked_address(0); if (!address) return -1; IG_COUNT(gDispatched,0); errno=incoming; ssize_t (*function)(int,const void *,size_t)=(void *)address; return function(fd,buffer,count); } __attribute__((used,noinline)) int IG_dispatch_close(int fd) { int incoming=errno; IG_COUNT(gAttempted,1); uintptr_t address=checked_address(1); if (!address) return -1; IG_COUNT(gDispatched,1); errno=incoming; int (*function)(int)=(void *)address; return function(fd); } int ig_dispatch_check(IGFindingSink sink, void *ctx) { int saved=errno, hits=0; int ready=prepare(); for (unsigned i=0;i<2;i++) { uintptr_t address=0; int reason=IG_REASON_DISPATCH_UNAVAILABLE; IGStatus status=ready ? validate(i,&address,&reason) : IG_UNAVAILABLE; if (status==IG_CLEAR) continue; IGFinding f={0}; f.status=status; f.reason=reason; const char *label=i==0 ? "dispatch-write" : "dispatch-close"; strncpy(f.subject,label,sizeof(f.subject)-1); strncpy(f.evidence,"调度地址、提供方或代码前缀校验未通过",sizeof(f.evidence)-1); if (status==IG_DETECTED) hits++; if (sink && sink(&f,ctx)!=0) break; } errno=saved; return hits; } #ifdef IG_OBSERVATION IGDispatchObservation ig_dispatch_observation(void) { IGDispatchObservation value={ atomic_load_explicit(&gAttempted[0],memory_order_relaxed), atomic_load_explicit(&gDispatched[0],memory_order_relaxed), atomic_load_explicit(&gAttempted[1],memory_order_relaxed), atomic_load_explicit(&gDispatched[1],memory_order_relaxed) }; return value; } #endif #ifdef IG_DISPATCH_TESTING void ig_dispatch_test_override(unsigned i, void *address) { if (i<2 && prepare()) atomic_store_explicit(&gSlots[i],(uintptr_t)address,memory_order_release); } void ig_dispatch_test_reentry(int enabled) { gResolving=enabled; } #endif