IlDivinoGlade

PS3 Process & Thread Hooking Framework

Sep 27th, 2025 (edited)
120
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 5.66 KB | None | 0 0
  1. #include <cell/cell_fs.h>
  2. #include <sys/process.h>
  3. #include <sys/ppu_thread.h>
  4. #include <stdio.h>
  5. #include <string.h>
  6.  
  7. //credit for stable hook: https://pastebin.com/u/TheRouletteBoi
  8. //credit for improvements code: https://chatgpt.com/
  9.  
  10. // Structure to track processes
  11. typedef struct {
  12.     sys_pid_t process_id;
  13.     sys_ppu_thread_t main_thread;
  14.     char process_name[256];
  15.     int status;
  16.     bool is_tracked;
  17. } tracked_process_t;
  18.  
  19. #define MAX_TRACKED_PROCESSES 64
  20. tracked_process_t tracked_processes[MAX_TRACKED_PROCESSES];
  21. int process_count = 0;
  22.  
  23. /**
  24.  * Hook for sys_process_spawn (process creation)
  25.  * Logs process creation and tracks new processes in the array
  26.  */
  27. ImportExportHook* sysProcessSpawnHk;
  28. int sysProcessSpawnHook(sys_pid_t* pid, const char* path, const char* argv[], const char* envp[],
  29.     sys_process_param_t* param, int priority, size_t stacksize, int flags,
  30.     const char* spu_elf_path)
  31. {
  32.     printf("[PROCESS HOOK] New process spawning:\n");
  33.     printf("  Path: %s\n", path ? path : "NULL");
  34.     printf("  Priority: %d\n", priority);
  35.     printf("  Stack Size: 0x%X\n", stacksize);
  36.     printf("  Flags: 0x%X\n", flags);
  37.  
  38.     // Call original function
  39.     int result = sysProcessSpawnHk->GetOriginal<int>(pid, path, argv, envp, param, priority, stacksize, flags, spu_elf_path);
  40.  
  41.     // If process created successfully, add it to tracking
  42.     if (result == CELL_OK && process_count < MAX_TRACKED_PROCESSES) {
  43.         tracked_processes[process_count].process_id = *pid;
  44.         strncpy(tracked_processes[process_count].process_name, path ? path : "Unknown", 255);
  45.         tracked_processes[process_count].status = 1; // Running
  46.         tracked_processes[process_count].is_tracked = true;
  47.  
  48.         printf("[PROCESS HOOK] Process added to tracking: PID=0x%X, Name=%s\n",
  49.             *pid, tracked_processes[process_count].process_name);
  50.         process_count++;
  51.     }
  52.  
  53.     return result;
  54. }
  55.  
  56. /**
  57.  * Hook for sys_process_exit (process termination)
  58.  * Updates tracking when a process exits
  59.  */
  60. ImportExportHook* sysProcessExitHk;
  61. void sysProcessExitHook(int status)
  62. {
  63.     // Get current PID using sys_process_getpid()
  64.     sys_pid_t current_pid = sys_process_getpid();
  65.  
  66.     printf("[PROCESS HOOK] Process exiting: PID=0x%X, Status=%d\n", current_pid, status);
  67.  
  68.     // Update status in tracking
  69.     for (int i = 0; i < process_count; i++) {
  70.         if (tracked_processes[i].process_id == current_pid && tracked_processes[i].is_tracked) {
  71.             tracked_processes[i].status = 0; // Stopped/Exited
  72.             printf("[PROCESS HOOK] Process stopped: %s (PID=0x%X)\n",
  73.                 tracked_processes[i].process_name, current_pid);
  74.             break;
  75.         }
  76.     }
  77.  
  78.     sysProcessExitHk->GetOriginal<void>(status);
  79. }
  80.  
  81. /**
  82.  * Hook for sys_ppu_thread_create (thread creation)
  83.  * Logs thread creation and associates main thread to tracked process
  84.  */
  85. ImportExportHook* sysPpuThreadCreateHk;
  86. int sysPpuThreadCreateHook(sys_ppu_thread_t* thread_id, void (*entry)(uint64_t arg), uint64_t arg,
  87.     int priority, size_t stacksize, uint64_t flags, const char* threadname)
  88. {
  89.     printf("[THREAD HOOK] New thread created:\n");
  90.     printf("  Name: %s\n", threadname ? threadname : "Unnamed");
  91.     printf("  Priority: %d\n", priority);
  92.     printf("  Stack Size: 0x%X\n", stacksize);
  93.     printf("  Flags: 0x%llX\n", flags);
  94.  
  95.     int result = sysPpuThreadCreateHk->GetOriginal<int>(thread_id, entry, arg, priority, stacksize, flags, threadname);
  96.  
  97.     if (result == CELL_OK) {
  98.         printf("[THREAD HOOK] Thread ID: 0x%X created successfully\n", *thread_id);
  99.  
  100.         // Associate thread with current process if tracked
  101.         sys_pid_t current_pid = sys_process_getpid();
  102.  
  103.         for (int i = 0; i < process_count; i++) {
  104.             if (tracked_processes[i].process_id == current_pid && tracked_processes[i].is_tracked) {
  105.                 if (tracked_processes[i].main_thread == 0) {
  106.                     tracked_processes[i].main_thread = *thread_id;
  107.                     printf("[THREAD HOOK] Main thread assigned to process %s\n",
  108.                         tracked_processes[i].process_name);
  109.                 }
  110.                 break;
  111.             }
  112.         }
  113.     }
  114.  
  115.     return result;
  116. }
  117.  
  118. /**
  119.  * Hook for sys_ppu_thread_exit (thread termination)
  120.  * Detects when a tracked main thread exits
  121.  */
  122. ImportExportHook* sysPpuThreadExitHk;
  123. void sysPpuThreadExitHook(uint64_t val)
  124. {
  125.     sys_ppu_thread_t current_thread_id;
  126.     sys_ppu_thread_get_id(&current_thread_id);
  127.  
  128.     printf("[THREAD HOOK] Thread exiting: ID=0x%X, Value=0x%llX\n", current_thread_id, val);
  129.  
  130.     // Check if it's the main thread of a tracked process
  131.     for (int i = 0; i < process_count; i++) {
  132.         if (tracked_processes[i].main_thread == current_thread_id && tracked_processes[i].is_tracked) {
  133.             printf("[THREAD HOOK] Main thread of process %s terminated\n",
  134.                 tracked_processes[i].process_name);
  135.             tracked_processes[i].status = 0; // Stopped
  136.             break;
  137.         }
  138.     }
  139.  
  140.     sysPpuThreadExitHk->GetOriginal<void>(val);
  141. }
  142.  
  143. /**
  144.  * Print the current tracked processes status
  145.  */
  146. void print_process_status()
  147. {
  148.     printf("\n=== TRACKED PROCESS STATUS ===\n");
  149.     for (int i = 0; i < process_count; i++) {
  150.         if (tracked_processes[i].is_tracked) {
  151.             printf("PID: 0x%X | Name: %s | Status: %s | Thread: 0x%X\n",
  152.                 tracked_processes[i].process_id,
  153.                 tracked_processes[i].process_name,
  154.                 tracked_processes[i].status ? "RUNNING" : "STOPPED",
  155.                 tracked_processes[i].main_thread);
  156.         }
  157.     }
  158.     printf("================================\n\n");
  159. }
  160.  
Advertisement
Add Comment
Please, Sign In to add comment