mirror of
https://github.com/UniXNU/UniXNU.git
synced 2026-11-18 10:01:39 +03:00
103 lines
5.6 KiB
C
103 lines
5.6 KiB
C
/* Run the exact kernel registration implementation with a locked mock runtime. */
|
|
#include <assert.h>
|
|
#include <pthread.h>
|
|
#include <stdatomic.h>
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
typedef int kern_return_t;
|
|
enum { KERN_SUCCESS, KERN_FAILURE, KERN_NOT_SUPPORTED, KERN_INVALID_ARGUMENT, KERN_RESOURCE_SHORTAGE };
|
|
enum { kTCReturnSuccess, kTCReturnNotFound, kTCReturnFailure, kTCQueryTypeAll = 0, kTCTypeEngineering = 1 };
|
|
#define Z_WAITOK_ZERO 0
|
|
typedef struct { uint8_t CDHash[20], hashType, flags, constraintCategory, reserved0; } TrustCacheEntry2_t;
|
|
typedef struct { uint32_t version; uint8_t uuid[16]; uint32_t numEntries; TrustCacheEntry2_t entries[]; } TrustCacheModule2_t;
|
|
typedef struct Cache { struct Cache *next; TrustCacheModule2_t *module; } TrustCache_t;
|
|
typedef struct { int unused; } TrustCacheQueryToken_t;
|
|
typedef struct { int error; } TCReturn_t;
|
|
static uint32_t enabled = 1;
|
|
static bool fail_load, fail_query, fail_alloc;
|
|
static atomic_int allocations;
|
|
static unsigned loads;
|
|
static TrustCache_t *head;
|
|
static int runtime, *trust_cache_rt = &runtime;
|
|
static pthread_mutex_t trust_cache_rt_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
static void *allocate(size_t size) {
|
|
if (fail_alloc) return NULL;
|
|
void *p = calloc(1, size); assert(p); atomic_fetch_add(&allocations, 1); return p;
|
|
}
|
|
static void release(void *p) { assert(p); atomic_fetch_sub(&allocations, 1); free(p); }
|
|
#define kalloc_type(type, flags) ((type *)allocate(sizeof(type)))
|
|
#define kalloc_data(size, flags) allocate(size)
|
|
#define kfree_type(type, ptr) release(ptr)
|
|
#define kfree_data(ptr, size) release(ptr)
|
|
#define lck_rw_lock_exclusive(lock) assert(pthread_mutex_lock(lock) == 0)
|
|
#define lck_rw_unlock_exclusive(lock) assert(pthread_mutex_unlock(lock) == 0)
|
|
static void PE_parse_boot_argn(const char *arg, void *output, size_t size) {
|
|
assert(!strcmp(arg, "appsync") && size == sizeof(enabled)); memcpy(output, &enabled, size);
|
|
}
|
|
static TCReturn_t query(int *rt, int type, const uint8_t *hash, TrustCacheQueryToken_t *token) {
|
|
assert(rt == trust_cache_rt && type == kTCQueryTypeAll && token);
|
|
if (fail_query) return (TCReturn_t){kTCReturnFailure};
|
|
for (TrustCache_t *c = head; c; c = c->next)
|
|
if (!memcmp(c->module->entries[0].CDHash, hash, 20)) return (TCReturn_t){kTCReturnSuccess};
|
|
return (TCReturn_t){kTCReturnNotFound};
|
|
}
|
|
static TCReturn_t load(int *rt, int type, TrustCache_t *cache, uintptr_t address, size_t size) {
|
|
assert(rt == trust_cache_rt && type == kTCTypeEngineering);
|
|
assert(size == sizeof(TrustCacheModule2_t) + sizeof(TrustCacheEntry2_t));
|
|
TrustCacheModule2_t *m = (void *)address;
|
|
assert(m->version == 2 && m->numEntries == 1);
|
|
assert(m->entries[0].flags == 0 && m->entries[0].constraintCategory == 0);
|
|
if (fail_load) return (TCReturn_t){kTCReturnFailure};
|
|
cache->module = m; cache->next = head; head = cache; ++loads;
|
|
return (TCReturn_t){kTCReturnSuccess};
|
|
}
|
|
static struct AMFI { struct {
|
|
TCReturn_t (*query)(int *, int, const uint8_t *, TrustCacheQueryToken_t *);
|
|
TCReturn_t (*loadModule)(int *, int, TrustCache_t *, uintptr_t, size_t);
|
|
} TrustCache; } mock_amfi = {{query, load}}, *amfi = &mock_amfi;
|
|
static kern_return_t xnu_query_trust_cache(int type, const uint8_t *hash, TrustCacheQueryToken_t *token) {
|
|
lck_rw_lock_exclusive(&trust_cache_rt_lock);
|
|
int error = query(trust_cache_rt, type, hash, token).error;
|
|
lck_rw_unlock_exclusive(&trust_cache_rt_lock);
|
|
return error == kTCReturnSuccess ? KERN_SUCCESS : KERN_FAILURE;
|
|
}
|
|
#include "appsync_trust.inc"
|
|
|
|
static const char *user_path = "/private/var/containers/Bundle/Application/NEW/New.app/New";
|
|
static void *racing_load(void *hash) {
|
|
assert(appsync_trust_user_code(user_path, hash, 2) == KERN_SUCCESS); return NULL;
|
|
}
|
|
int main(void) {
|
|
uint8_t hashes[5][20] = {{1}, {2}, {3}, {4}, {5}};
|
|
const char *foreign[] = {"/System/Applications/One.app/One", "/private/var-other/One.app/One",
|
|
"/private/var/One.appx/One", "/private/var/.app/One", "/private/var/One.app/../Other/Code"};
|
|
for (unsigned i = 0; i < sizeof(foreign)/sizeof(*foreign); ++i)
|
|
assert(appsync_trust_user_code(foreign[i], hashes[0], 2) == KERN_SUCCESS);
|
|
enabled = 0;
|
|
assert(appsync_trust_user_code(user_path, hashes[0], 2) == KERN_SUCCESS);
|
|
assert(loads == 0 && allocations == 0);
|
|
enabled = 1;
|
|
pthread_t threads[32];
|
|
for (unsigned i = 0; i < 32; ++i) assert(!pthread_create(&threads[i], NULL, racing_load, hashes[0]));
|
|
for (unsigned i = 0; i < 32; ++i) assert(!pthread_join(threads[i], NULL));
|
|
assert(loads == 1 && allocations == 2);
|
|
assert(appsync_trust_user_code("/var/containers/Bundle/Application/NEW/New.app/Frameworks/F.framework/F", hashes[1], 1) == KERN_SUCCESS);
|
|
assert(appsync_trust_user_code(user_path, hashes[2], 2) == KERN_SUCCESS); // new app version, same path
|
|
assert(loads == 3 && allocations == 6);
|
|
fail_load = true;
|
|
assert(appsync_trust_user_code(user_path, hashes[3], 2) == KERN_FAILURE);
|
|
fail_load = false; fail_query = true;
|
|
assert(appsync_trust_user_code(user_path, hashes[3], 2) == KERN_FAILURE);
|
|
fail_query = false; fail_alloc = true;
|
|
assert(appsync_trust_user_code(user_path, hashes[3], 2) == KERN_RESOURCE_SHORTAGE);
|
|
fail_alloc = false;
|
|
assert(appsync_trust_user_code(user_path, hashes[3], 0) == KERN_INVALID_ARGUMENT);
|
|
assert(loads == 3 && allocations == 6);
|
|
while (head) { TrustCache_t *next = head->next; release(head->module); release(head); head = next; }
|
|
assert(allocations == 0);
|
|
puts("PASS: dynamic user trust, unlisted apps/updates/frameworks, concurrency, disabled scope and failures");
|
|
}
|