fix: reverting cuz it doesnt work

Author: cr4zyengineer

Config.xcconfig

@@ -9,4 +9,4 @@
 // https://developer.apple.com/documentation/xcode/adding-a-build-configuration-file-to-your-project
 
 VERSION = 0.9.0
-BUILD_NUMBER = 20260223.96.US.seanistethered
+BUILD_NUMBER = 20260223.102.US.seanistethered

Nyxian/LindChain/Debugger/Utils.h

@@ -95,6 +95,8 @@ bool thread_restore_state_arm64(thread_act_t thread, struct arm64_thread_full_st
 void state_back_trace(struct arm64_thread_full_state *state, uint64_t maxdepth);
 
 kern_return_t task_thread_index(task_t task, thread_t target, mach_msg_type_number_t *index);
+kern_return_t task_thread_get_unique_id(thread_t thread, uint64_t *unique_id);
+kern_return_t task_thread_for_unique_id(task_t task, uint64_t unique_id, thread_t *out_thread);
 
 uint64_t get_next_pc(struct arm64_thread_full_state *state);
 bool pc_at_software_breakpoint(struct arm64_thread_full_state *state);

Nyxian/LindChain/Debugger/Utils.m

@@ -130,6 +130,67 @@ kern_return_t task_thread_index(task_t task,
     return kr;
 }
 
+kern_return_t task_thread_get_unique_id(thread_t thread,
+                                        uint64_t *unique_id)
+{
+    if(thread == MACH_PORT_NULL || unique_id == NULL)
+    {
+        return KERN_INVALID_ARGUMENT;
+    }
+
+    thread_identifier_info_data_t info;
+    mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT;
+    kern_return_t kr = thread_info(thread, THREAD_IDENTIFIER_INFO, (thread_info_t)&info, &count);
+    if(kr != KERN_SUCCESS)
+    {
+        return kr;
+    }
+
+    *unique_id = info.thread_id;
+    return KERN_SUCCESS;
+}
+
+kern_return_t task_thread_for_unique_id(task_t task,
+                                        uint64_t unique_id,
+                                        thread_t *out_thread)
+{
+    if(task == MACH_PORT_NULL || out_thread == NULL)
+    {
+        return KERN_INVALID_ARGUMENT;
+    }
+
+    thread_act_array_t threads;
+    mach_msg_type_number_t count;
+
+    kern_return_t kr = task_threads(task, &threads, &count);
+    if(kr != KERN_SUCCESS)
+    {
+        return kr;
+    }
+
+    kern_return_t result = KERN_FAILURE;
+    *out_thread = MACH_PORT_NULL;
+
+    for(mach_msg_type_number_t i = 0; i < count; i++)
+    {
+        uint64_t tid = 0;
+        kern_return_t ikr = task_thread_get_unique_id(threads[i], &tid);
+
+        if(ikr == KERN_SUCCESS && tid == unique_id)
+        {
+            *out_thread = threads[i];
+            result = KERN_SUCCESS;
+        }
+        else
+        {
+            mach_port_deallocate(mach_task_self(), threads[i]);
+        }
+    }
+
+    vm_deallocate(mach_task_self(), (vm_address_t)threads, count * sizeof(thread_act_t));
+    return result;
+}
+
 static bool evaluate_condition(uint32_t cond,
                                uint32_t cpsr)
 {

Nyxian/LindChain/ProcEnvironment/Syscall/mach_syscall_client.m

@@ -136,7 +136,14 @@ int64_t syscall_invoke(syscall_client_t *client,
     buffer.req.header.msgh_local_port = client->reply_port;
     buffer.req.header.msgh_size = sizeof(syscall_request_t);
     buffer.req.header.msgh_id = syscall_num;
-    buffer.req.thread = mach_thread_self();
+    
+    kern_return_t kr = task_thread_get_unique_id(mach_thread_self(), &(buffer.req.thread));
+    
+    if(kr != KERN_SUCCESS)
+    {
+        errno = EAGAIN;
+        return -1;
+    }
 
     /* telling cutie patootie ksurface what syscall we wanna call ^^ */
     buffer.req.syscall_num = syscall_num;
@@ -169,7 +176,7 @@ int64_t syscall_invoke(syscall_client_t *client,
      * uses the same buffer for both operations. The receive buffer size
      * must be large enough to hold the reply plus any trailer.
      */
-    kern_return_t kr = mach_msg(&buffer.req.header, MACH_SEND_MSG | MACH_RCV_MSG, sizeof(syscall_request_t), sizeof(buffer), client->reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+    kr = mach_msg(&buffer.req.header, MACH_SEND_MSG | MACH_RCV_MSG, sizeof(syscall_request_t), sizeof(buffer), client->reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
 
     /* checking for succession */
     if(kr != KERN_SUCCESS)

Nyxian/LindChain/ProcEnvironment/Syscall/mach_syscall_server.m

@@ -212,78 +212,67 @@ static void send_reply(mach_msg_header_t *request,
         }
         else
         {
-            kr = mach_port_mod_refs(task, req->thread, MACH_PORT_RIGHT_SEND, 1);
-            
-            if(kr != KERN_SUCCESS)
-            {
-                goto skip_thread_port_extraction;
-            }
-            
-            kr = mach_port_extract_right(task, req->thread, MACH_MSG_TYPE_COPY_SEND, &thread, NULL);
-            
+            kr = task_thread_for_unique_id(task, req->thread, &thread);
             if(kr != KERN_SUCCESS)
             {
-                mach_port_mod_refs(task, req->thread, MACH_PORT_RIGHT_SEND, -1);
-                req->thread = MACH_PORT_NULL;
-                goto skip_thread_port_extraction;
+                err = EAGAIN;
+                result = -1;
+                goto cleanup;
             }
         }
 
-    skip_thread_port_extraction:
+        /* getting the syscall handler the kernel virtualisation layer previously has set */
+        syscall_handler_t handler = NULL;
+        
+        /* checking syscall bounds */
+        if(req->syscall_num < MAX_SYSCALLS)
         {
-            /* getting the syscall handler the kernel virtualisation layer previously has set */
-            syscall_handler_t handler = NULL;
-            
-            /* checking syscall bounds */
-            if(req->syscall_num < MAX_SYSCALLS)
-            {
-                /* getting handler if bounds are valid */
-                handler = server->handlers[req->syscall_num];
-            }
-            
-            /* checking if the handler was set by the kernel virtualisation layer */
-            if(!handler)
-            {
-                klog_log(@"syscall", @"syscall from pid %d failed (EXCEPTION: %d is not a valid syscall)", proc_getpid(proc_copy), req->syscall_num);
-                err = ENOSYS;
-                result = -1;
-                goto cleanup;
-            }
-            
-            /* calling syscall handler */
-            result = handler(task, thread, proc_copy, req->args, (req->oolp.disposition == MACH_MSG_TYPE_MOVE_RECEIVE) ? NULL: (mach_port_t*)(req->oolp.address), (req->oolp.disposition == MACH_MSG_TYPE_MOVE_RECEIVE) ? 0 : req->oolp.count, &out_ports, &out_ports_cnt, &err, &name, (req->oolp.disposition == MACH_MSG_TYPE_MOVE_RECEIVE) ? *((mach_port_t*)req->oolp.address) : MACH_PORT_NULL);
-            
-        cleanup:
-            
-            /* deallocate what the guest requested via input ports (avoiding port leaks is a extremely good idea ^^) */
-            vm_deallocate(mach_task_self(), (mach_vm_address_t)req->oolp.address, req->oolp.count * sizeof(mach_port_t));
-            
-            /* destroying copy of process */
-            if(proc_copy != NULL)
-            {
-                /* check for errno and log if errno is indeed set */
-                if(err != 0 && err != ENOSYS)
-                {
-                    klog_log(@"syscall", @"syscall(%s) from pid %d failed (ERRNO=%s)", name, proc_getpid(proc_copy), strerror(err));
-                }
-                
-                proc_copy_destroy(proc_copy);
-            }
-            
-            /* checking task and thread */
-            if(task != MACH_PORT_NULL)
-            {
-                mach_port_deallocate(mach_task_self(), task);
-            }
-            
-            if(thread != MACH_PORT_NULL)
+            /* getting handler if bounds are valid */
+            handler = server->handlers[req->syscall_num];
+        }
+        
+        /* checking if the handler was set by the kernel virtualisation layer */
+        if(!handler)
+        {
+            klog_log(@"syscall", @"syscall from pid %d failed (EXCEPTION: %d is not a valid syscall)", proc_getpid(proc_copy), req->syscall_num);
+            err = ENOSYS;
+            result = -1;
+            goto cleanup;
+        }
+        
+        /* calling syscall handler */
+        result = handler(task, thread, proc_copy, req->args, (req->oolp.disposition == MACH_MSG_TYPE_MOVE_RECEIVE) ? NULL: (mach_port_t*)(req->oolp.address), (req->oolp.disposition == MACH_MSG_TYPE_MOVE_RECEIVE) ? 0 : req->oolp.count, &out_ports, &out_ports_cnt, &err, &name, (req->oolp.disposition == MACH_MSG_TYPE_MOVE_RECEIVE) ? *((mach_port_t*)req->oolp.address) : MACH_PORT_NULL);
+        
+    cleanup:
+
+        /* deallocate what the guest requested via input ports (avoiding port leaks is a extremely good idea ^^) */
+        vm_deallocate(mach_task_self(), (mach_vm_address_t)req->oolp.address, req->oolp.count * sizeof(mach_port_t));
+        
+        /* destroying copy of process */
+        if(proc_copy != NULL)
+        {
+            /* check for errno and log if errno is indeed set */
+            if(err != 0 && err != ENOSYS)
             {
-                mach_port_deallocate(mach_task_self(), thread);
+                klog_log(@"syscall", @"syscall(%s) from pid %d failed (ERRNO=%s)", name, proc_getpid(proc_copy), strerror(err));
             }
 
-            /* reply !!!AFTER!!! deallocation */
-            send_reply(&buffer.header, result, out_ports, out_ports_cnt, err);
+            proc_copy_destroy(proc_copy);
         }
+        
+        /* checking task and thread */
+        if(task != MACH_PORT_NULL)
+        {
+            mach_port_deallocate(mach_task_self(), task);
+        }
+        
+        if(thread != MACH_PORT_NULL)
+        {
+            mach_port_deallocate(mach_task_self(), thread);
+        }
+        
+        /* reply !!!AFTER!!! deallocation */
+        send_reply(&buffer.header, result, out_ports, out_ports_cnt, err);
     }
 
     return NULL;