YJN/selfpatch-slr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Selfpatch typedefs

Browse Source
This commit is contained in:
York Jasper Niebuhr 2026-04-07 23:31:14 +02:00
parent 2a60879bbb
commit 640cf0d401
8 changed files with 167 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
selfpatch/src/env.c
View File

@ -13,11 +13,11 @@ static int spslr_env_get_prot(void* addr, int* prot) {
if (!f) if (!f)
return -1; return -1;
uintptr_t query = (uintptr_t)addr; spslr_uintptr query = (spslr_uintptr)addr;
char line[512]; char line[512];
while (fgets(line, sizeof(line), f)) { while (fgets(line, sizeof(line), f)) {
uintptr_t start, end; spslr_uintptr start, end;
char perms[5]; char perms[5];
if (sscanf(line, "%lx-%lx %4s", &start, &end, perms) != 3) if (sscanf(line, "%lx-%lx %4s", &start, &end, perms) != 3)
@ -43,14 +43,14 @@ static int spslr_env_get_prot(void* addr, int* prot) {
return -1; return -1;
} }
static void spslr_env_poke_safe(void* dst, const void* src, uint32_t n) { static void spslr_env_poke_safe(void* dst, const void* src, spslr_u32 n) {
int original_prot; int original_prot;
if (spslr_env_get_prot(dst, &original_prot)) if (spslr_env_get_prot(dst, &original_prot))
spslr_env_panic("failed to get prot of text poke destination"); spslr_env_panic("failed to get prot of text poke destination");
uint64_t ptr_uint = (uint64_t)dst; spslr_u64 ptr_uint = (spslr_u64)dst;
uint64_t ptr_page = ptr_uint & PAGE_MASK; spslr_u64 ptr_page = ptr_uint & PAGE_MASK;
uint64_t prot_size = n + (ptr_uint - ptr_page); spslr_u64 prot_size = n + (ptr_uint - ptr_page);
int tmp_prot = original_prot | PROT_WRITE; int tmp_prot = original_prot | PROT_WRITE;
@ -68,23 +68,23 @@ void spslr_env_panic(const char* reason) {
exit(1); exit(1);
} }
void spslr_env_poke_text_8(void* dst, uint8_t value) { void spslr_env_poke_text_8(void* dst, spslr_u8 value) {
spslr_env_poke_safe(dst, &value, sizeof(value)); spslr_env_poke_safe(dst, &value, sizeof(value));
} }
void spslr_env_poke_text_16(void* dst, uint16_t value) { void spslr_env_poke_text_16(void* dst, spslr_u16 value) {
spslr_env_poke_safe(dst, &value, sizeof(value)); spslr_env_poke_safe(dst, &value, sizeof(value));
} }
void spslr_env_poke_text_32(void* dst, uint32_t value) { void spslr_env_poke_text_32(void* dst, spslr_u32 value) {
spslr_env_poke_safe(dst, &value, sizeof(value)); spslr_env_poke_safe(dst, &value, sizeof(value));
} }
void spslr_env_poke_text_64(void* dst, uint64_t value) { void spslr_env_poke_text_64(void* dst, spslr_u64 value) {
spslr_env_poke_safe(dst, &value, sizeof(value)); spslr_env_poke_safe(dst, &value, sizeof(value));
} }
void* spslr_env_malloc(uint32_t n) { void* spslr_env_malloc(spslr_u32 n) {
void* res = malloc(n); void* res = malloc(n);
if (!res) if (!res)
spslr_env_panic("malloc failed"); spslr_env_panic("malloc failed");
@ -96,26 +96,26 @@ void spslr_env_free(void* ptr) {
free(ptr); free(ptr);
} }
void spslr_env_poke_data(void* dst, const void* src, uint32_t n) { void spslr_env_poke_data(void* dst, const void* src, spslr_u32 n) {
spslr_env_poke_safe(dst, src, n); spslr_env_poke_safe(dst, src, n);
} }
void spslr_env_memset(void* dst, int v, uint32_t n) { void spslr_env_memset(void* dst, int v, spslr_u32 n) {
memset(dst, v, n); memset(dst, v, n);
} }
void spslr_env_memcpy(void* dst, const void* src, uint32_t n) { void spslr_env_memcpy(void* dst, const void* src, spslr_u32 n) {
memcpy(dst, src, n); memcpy(dst, src, n);
} }
static int rand_initialized = 0; static int rand_initialized = 0;
uint32_t spslr_env_random_u32() { spslr_u32 spslr_env_random_u32() {
if (!rand_initialized) { if (!rand_initialized) {
srand(time(NULL)); srand(time(SPSLR_NULL));
rand_initialized = 1; rand_initialized = 1;
} }
return (uint32_t)rand(); return (spslr_u32)rand();
} }

20
selfpatch/src/env.h
View File

@ -1,18 +1,18 @@
#ifndef SPSLR_ENV_H #ifndef SPSLR_ENV_H
#define SPSLR_ENV_H #define SPSLR_ENV_H
#include <stdint.h> #include "spslr_types.h"
void spslr_env_panic(const char* reason); void spslr_env_panic(const char* reason);
void spslr_env_poke_text_8(void* dst, uint8_t value); void spslr_env_poke_text_8(void* dst, spslr_u8 value);
void spslr_env_poke_text_16(void* dst, uint16_t value); void spslr_env_poke_text_16(void* dst, spslr_u16 value);
void spslr_env_poke_text_32(void* dst, uint32_t value); void spslr_env_poke_text_32(void* dst, spslr_u32 value);
void spslr_env_poke_text_64(void* dst, uint64_t value); void spslr_env_poke_text_64(void* dst, spslr_u64 value);
void* spslr_env_malloc(uint32_t n); // Either return valid buffer or panic internally void* spslr_env_malloc(spslr_u32 n); // Either return valid buffer or panic internally
void spslr_env_free(void* ptr); void spslr_env_free(void* ptr);
void spslr_env_poke_data(void* dst, const void* src, uint32_t n); void spslr_env_poke_data(void* dst, const void* src, spslr_u32 n);
void spslr_env_memset(void* dst, int v, uint32_t n); void spslr_env_memset(void* dst, int v, spslr_u32 n);
void spslr_env_memcpy(void* dst, const void* src, uint32_t n); void spslr_env_memcpy(void* dst, const void* src, spslr_u32 n);
uint32_t spslr_env_random_u32(); spslr_u32 spslr_env_random_u32();
#endif #endif

122
selfpatch/src/randomizer.c
View File

@ -3,12 +3,10 @@
#include "spslr_list_link.h" #include "spslr_list_link.h"
#include "env.h" #include "env.h"
#include <stddef.h>
struct Field { struct Field {
uint32_t offset; /* Final field offset -> fields[i].offset = offset of field i in final layout */ spslr_u32 offset; /* Final field offset -> fields[i].offset = offset of field i in final layout */
uint32_t oidx; /* Original field idx -> fields[i].oidx = original position of field i in final layout */ spslr_u32 oidx; /* Original field idx -> fields[i].oidx = original position of field i in final layout */
uint32_t fidx; /* Final field idx -> fields[i].fidx = randomized/final position of original field i */ spslr_u32 fidx; /* Final field idx -> fields[i].fidx = randomized/final position of original field i */
}; };
static struct Field* fields; static struct Field* fields;
@ -18,11 +16,11 @@ int spslr_randomizer_init() {
if (!fields) if (!fields)
return -1; return -1;
for (uint32_t tidx = 0; tidx < spslr_target_cnt; tidx++) { for (spslr_u32 tidx = 0; tidx < spslr_target_cnt; tidx++) {
const struct spslr_target* t = &spslr_targets[tidx]; const struct spslr_target* t = &spslr_targets[tidx];
for (uint32_t fidx = 0; fidx < t->fieldcnt; fidx++) { for (spslr_u32 fidx = 0; fidx < t->fieldcnt; fidx++) {
uint32_t gfidx = t->fieldoff + fidx; spslr_u32 gfidx = t->fieldoff + fidx;
const struct spslr_target_field* srcf = &spslr_target_fields[gfidx]; const struct spslr_target_field* srcf = &spslr_target_fields[gfidx];
struct Field* dstf = &fields[gfidx]; struct Field* dstf = &fields[gfidx];
@ -41,10 +39,10 @@ void spslr_randomizer_clear() {
return; return;
spslr_env_free(fields); spslr_env_free(fields);
fields = NULL; fields = SPSLR_NULL;
} }
int spslr_randomizer_get_target(uint32_t target, uint32_t* size, uint32_t* fieldcnt) { int spslr_randomizer_get_target(spslr_u32 target, spslr_u32* size, spslr_u32* fieldcnt) {
if (target >= spslr_target_cnt) if (target >= spslr_target_cnt)
return -1; return -1;
@ -59,7 +57,7 @@ int spslr_randomizer_get_target(uint32_t target, uint32_t* size, uint32_t* field
return 0; return 0;
} }
int spslr_randomizer_get_field(uint32_t target, uint32_t field, int field_idx_mode, int spslr_randomizer_get_field(spslr_u32 target, spslr_u32 field, int field_idx_mode,
struct spslr_randomizer_field_info* info) { struct spslr_randomizer_field_info* info) {
if (target >= spslr_target_cnt) if (target >= spslr_target_cnt)
return -1; return -1;
@ -72,8 +70,8 @@ int spslr_randomizer_get_field(uint32_t target, uint32_t field, int field_idx_mo
if (field >= t->fieldcnt) if (field >= t->fieldcnt)
return -1; return -1;
const struct spslr_target_field* of = NULL; const struct spslr_target_field* of = SPSLR_NULL;
const struct Field* rf = NULL; const struct Field* rf = SPSLR_NULL;
switch (field_idx_mode) { switch (field_idx_mode) {
case SPSLR_RANDOMIZER_FIELD_IDX_MODE_ORIGINAL: case SPSLR_RANDOMIZER_FIELD_IDX_MODE_ORIGINAL:
@ -100,38 +98,38 @@ int spslr_randomizer_get_field(uint32_t target, uint32_t field, int field_idx_mo
// RANDOMIZATION CODE // RANDOMIZATION CODE
struct ShuffleRegion { struct ShuffleRegion {
uint32_t begin; spslr_u32 begin;
uint32_t end; spslr_u32 end;
uint32_t fill_begin; spslr_u32 fill_begin;
uint32_t fill_end; spslr_u32 fill_end;
}; };
static uint32_t rand_u32(void); static spslr_u32 rand_u32(void);
static struct Field* get_rfield(uint32_t target, uint32_t final_idx); static struct Field* get_rfield(spslr_u32 target, spslr_u32 final_idx);
static const struct spslr_target_field* get_ofield(uint32_t target, uint32_t orig_idx); static const struct spslr_target_field* get_ofield(spslr_u32 target, spslr_u32 orig_idx);
static void get_origin_region(uint32_t target, uint32_t final_idx, struct ShuffleRegion* region); static void get_origin_region(spslr_u32 target, spslr_u32 final_idx, struct ShuffleRegion* region);
static int pick_shuffle_option(uint32_t target, uint32_t origin_final_idx, static int pick_shuffle_option(spslr_u32 target, spslr_u32 origin_final_idx,
const struct ShuffleRegion* origin, uint32_t alignment, uint32_t* selected); const struct ShuffleRegion* origin, spslr_u32 alignment, spslr_u32* selected);
static void do_swap(uint32_t target, uint32_t origin_final_idx, static void do_swap(spslr_u32 target, spslr_u32 origin_final_idx,
const struct ShuffleRegion* origin_region, uint32_t new_offset); const struct ShuffleRegion* origin_region, spslr_u32 new_offset);
static void shuffle_one_target(uint32_t target); static void shuffle_one_target(spslr_u32 target);
static void shuffle_target(uint32_t target); static void shuffle_target(spslr_u32 target);
static uint32_t rand_u32(void) { static spslr_u32 rand_u32(void) {
return spslr_env_random_u32(); return spslr_env_random_u32();
} }
static struct Field* get_rfield(uint32_t target, uint32_t final_idx) { static struct Field* get_rfield(spslr_u32 target, spslr_u32 final_idx) {
const struct spslr_target* t = &spslr_targets[target]; const struct spslr_target* t = &spslr_targets[target];
return &fields[t->fieldoff + final_idx]; return &fields[t->fieldoff + final_idx];
} }
static const struct spslr_target_field* get_ofield(uint32_t target, uint32_t orig_idx) { static const struct spslr_target_field* get_ofield(spslr_u32 target, spslr_u32 orig_idx) {
const struct spslr_target* t = &spslr_targets[target]; const struct spslr_target* t = &spslr_targets[target];
return &spslr_target_fields[t->fieldoff + orig_idx]; return &spslr_target_fields[t->fieldoff + orig_idx];
} }
static void get_origin_region(uint32_t target, uint32_t final_idx, struct ShuffleRegion* region) { static void get_origin_region(spslr_u32 target, spslr_u32 final_idx, struct ShuffleRegion* region) {
const struct spslr_target* t = &spslr_targets[target]; const struct spslr_target* t = &spslr_targets[target];
const struct Field* rf = get_rfield(target, final_idx); const struct Field* rf = get_rfield(target, final_idx);
const struct spslr_target_field* of = get_ofield(target, rf->oidx); const struct spslr_target_field* of = get_ofield(target, rf->oidx);
@ -155,20 +153,20 @@ static void get_origin_region(uint32_t target, uint32_t final_idx, struct Shuffl
} }
} }
static int option_is_valid(uint32_t target, uint32_t origin_final_idx, const struct ShuffleRegion* origin, uint32_t offset) { static int option_is_valid(spslr_u32 target, spslr_u32 origin_final_idx, const struct ShuffleRegion* origin, spslr_u32 offset) {
const struct spslr_target* t = &spslr_targets[target]; const struct spslr_target* t = &spslr_targets[target];
const struct spslr_target_field* origin_of = const struct spslr_target_field* origin_of =
get_ofield(target, get_rfield(target, origin_final_idx)->oidx); get_ofield(target, get_rfield(target, origin_final_idx)->oidx);
// When placed at offset, field will occupy [offset, option_would_end) // When placed at offset, field will occupy [offset, option_would_end)
uint32_t option_would_end = offset + origin_of->size; spslr_u32 option_would_end = offset + origin_of->size;
if (option_would_end > t->size) if (option_would_end > t->size)
return 0; return 0;
// Field may overlap with origin region. Moving field to offset truly frees: // Field may overlap with origin region. Moving field to offset truly frees:
// [true_origin_region_begin, true_origin_region_end) // [true_origin_region_begin, true_origin_region_end)
uint32_t true_origin_region_begin = origin->begin; spslr_u32 true_origin_region_begin = origin->begin;
uint32_t true_origin_region_end = origin->end; spslr_u32 true_origin_region_end = origin->end;
if (offset <= origin->fill_begin && option_would_end > true_origin_region_begin) if (offset <= origin->fill_begin && option_would_end > true_origin_region_begin)
true_origin_region_begin = option_would_end; true_origin_region_begin = option_would_end;
@ -177,8 +175,8 @@ static int option_is_valid(uint32_t target, uint32_t origin_final_idx, const str
true_origin_region_end = offset; true_origin_region_end = offset;
// Iterate over fields in target region [offset, option_would_end] and see if they fit into true origin region // Iterate over fields in target region [offset, option_would_end] and see if they fit into true origin region
uint32_t origin_region_ptr = true_origin_region_begin; spslr_u32 origin_region_ptr = true_origin_region_begin;
for (uint32_t it = 0; it < t->fieldcnt; it++) { for (spslr_u32 it = 0; it < t->fieldcnt; it++) {
const struct Field* rf = get_rfield(target, it); const struct Field* rf = get_rfield(target, it);
const struct spslr_target_field* of = get_ofield(target, rf->oidx); const struct spslr_target_field* of = get_ofield(target, rf->oidx);
@ -212,12 +210,12 @@ static int option_is_valid(uint32_t target, uint32_t origin_final_idx, const str
return 1; return 1;
} }
static int pick_shuffle_option(uint32_t target, uint32_t origin_final_idx, const struct ShuffleRegion* origin, static int pick_shuffle_option(spslr_u32 target, spslr_u32 origin_final_idx, const struct ShuffleRegion* origin,
uint32_t alignment, uint32_t* selected) { spslr_u32 alignment, spslr_u32* selected) {
const struct spslr_target* t = &spslr_targets[target]; const struct spslr_target* t = &spslr_targets[target];
uint32_t seen = 0; spslr_u32 seen = 0;
for (uint32_t offset = 0; offset < t->size; offset += alignment) { for (spslr_u32 offset = 0; offset < t->size; offset += alignment) {
if (!option_is_valid(target, origin_final_idx, origin, offset)) if (!option_is_valid(target, origin_final_idx, origin, offset))
continue; continue;
@ -230,21 +228,21 @@ static int pick_shuffle_option(uint32_t target, uint32_t origin_final_idx, const
return seen ? 0 : -1; return seen ? 0 : -1;
} }
static void do_swap(uint32_t target, uint32_t origin_idx, static void do_swap(spslr_u32 target, spslr_u32 origin_idx,
const struct ShuffleRegion* origin_region, uint32_t new_offset) { const struct ShuffleRegion* origin_region, spslr_u32 new_offset) {
const struct spslr_target* t = &spslr_targets[target]; const struct spslr_target* t = &spslr_targets[target];
int pulled = 0; int pulled = 0;
uint32_t option_fill_end = new_offset + (origin_region->fill_end - origin_region->fill_begin); spslr_u32 option_fill_end = new_offset + (origin_region->fill_end - origin_region->fill_begin);
uint32_t true_origin_region_begin = origin_region->begin; spslr_u32 true_origin_region_begin = origin_region->begin;
if (new_offset <= origin_region->fill_begin && option_fill_end > true_origin_region_begin) if (new_offset <= origin_region->fill_begin && option_fill_end > true_origin_region_begin)
true_origin_region_begin = option_fill_end; true_origin_region_begin = option_fill_end;
uint32_t origin_oidx = get_rfield(target, origin_idx)->oidx; spslr_u32 origin_oidx = get_rfield(target, origin_idx)->oidx;
uint32_t origin_region_ptr = true_origin_region_begin; spslr_u32 origin_region_ptr = true_origin_region_begin;
for (uint32_t it = 0; it < t->fieldcnt; it++) { for (spslr_u32 it = 0; it < t->fieldcnt; it++) {
struct Field* itf = get_rfield(target, it); struct Field* itf = get_rfield(target, it);
if (itf->oidx == origin_oidx) if (itf->oidx == origin_oidx)
@ -258,7 +256,7 @@ static void do_swap(uint32_t target, uint32_t origin_idx,
if (itf->offset >= option_fill_end) if (itf->offset >= option_fill_end)
break; break;
uint32_t falign = itof->alignment; spslr_u32 falign = itof->alignment;
if (origin_region_ptr % falign != 0) if (origin_region_ptr % falign != 0)
origin_region_ptr += falign - (origin_region_ptr % falign); origin_region_ptr += falign - (origin_region_ptr % falign);
@ -280,19 +278,19 @@ static void do_swap(uint32_t target, uint32_t origin_idx,
struct Field tmp = *get_rfield(target, it); struct Field tmp = *get_rfield(target, it);
if (origin_idx >= it) { if (origin_idx >= it) {
for (uint32_t pull_it = it + 1; pull_it <= origin_idx; pull_it++) for (spslr_u32 pull_it = it + 1; pull_it <= origin_idx; pull_it++)
*get_rfield(target, pull_it - 1) = *get_rfield(target, pull_it); *get_rfield(target, pull_it - 1) = *get_rfield(target, pull_it);
*get_rfield(target, origin_idx) = tmp; *get_rfield(target, origin_idx) = tmp;
get_rfield(target, origin_idx)->offset = origin_region_ptr; get_rfield(target, origin_idx)->offset = origin_region_ptr;
origin_region_ptr += get_ofield(target, get_rfield(target, origin_idx)->oidx)->size; origin_region_ptr += get_ofield(target, get_rfield(target, origin_idx)->oidx)->size;
} else { } else {
for (uint32_t pull_it = it; pull_it > origin_idx + (uint32_t)pulled; pull_it--) for (spslr_u32 pull_it = it; pull_it > origin_idx + (spslr_u32)pulled; pull_it--)
*get_rfield(target, pull_it) = *get_rfield(target, pull_it - 1); *get_rfield(target, pull_it) = *get_rfield(target, pull_it - 1);
*get_rfield(target, origin_idx + (uint32_t)pulled) = tmp; *get_rfield(target, origin_idx + (spslr_u32)pulled) = tmp;
get_rfield(target, origin_idx + (uint32_t)pulled)->offset = origin_region_ptr; get_rfield(target, origin_idx + (spslr_u32)pulled)->offset = origin_region_ptr;
origin_region_ptr += get_ofield(target, get_rfield(target, origin_idx + (uint32_t)pulled)->oidx)->size; origin_region_ptr += get_ofield(target, get_rfield(target, origin_idx + (spslr_u32)pulled)->oidx)->size;
} }
} }
@ -302,18 +300,18 @@ static void do_swap(uint32_t target, uint32_t origin_idx,
/* /*
* Rebuild original->final mapping for this target. * Rebuild original->final mapping for this target.
*/ */
for (uint32_t final_idx = 0; final_idx < t->fieldcnt; final_idx++) { for (spslr_u32 final_idx = 0; final_idx < t->fieldcnt; final_idx++) {
struct Field* rf = get_rfield(target, final_idx); struct Field* rf = get_rfield(target, final_idx);
fields[t->fieldoff + rf->oidx].fidx = final_idx; fields[t->fieldoff + rf->oidx].fidx = final_idx;
} }
} }
static void shuffle_one_target(uint32_t target) { static void shuffle_one_target(spslr_u32 target) {
const struct spslr_target* t = &spslr_targets[target]; const struct spslr_target* t = &spslr_targets[target];
if (t->fieldcnt == 0) if (t->fieldcnt == 0)
return; return;
uint32_t origin_final_idx = rand_u32() % t->fieldcnt; spslr_u32 origin_final_idx = rand_u32() % t->fieldcnt;
struct Field* origin_rf = get_rfield(target, origin_final_idx); struct Field* origin_rf = get_rfield(target, origin_final_idx);
const struct spslr_target_field* origin_of = get_ofield(target, origin_rf->oidx); const struct spslr_target_field* origin_of = get_ofield(target, origin_rf->oidx);
@ -321,7 +319,7 @@ static void shuffle_one_target(uint32_t target) {
return; return;
struct ShuffleRegion origin_region; struct ShuffleRegion origin_region;
uint32_t selected_option; spslr_u32 selected_option;
get_origin_region(target, origin_final_idx, &origin_region); get_origin_region(target, origin_final_idx, &origin_region);
@ -332,11 +330,11 @@ static void shuffle_one_target(uint32_t target) {
do_swap(target, origin_final_idx, &origin_region, selected_option); do_swap(target, origin_final_idx, &origin_region, selected_option);
} }
static void shuffle_target(uint32_t target) { static void shuffle_target(spslr_u32 target) {
const struct spslr_target* t = &spslr_targets[target]; const struct spslr_target* t = &spslr_targets[target];
uint32_t shuffle_count = t->fieldcnt * 2; spslr_u32 shuffle_count = t->fieldcnt * 2;
for (uint32_t i = 0; i < shuffle_count; i++) for (spslr_u32 i = 0; i < shuffle_count; i++)
shuffle_one_target(target); shuffle_one_target(target);
} }
@ -344,7 +342,7 @@ int spslr_randomize() {
if (!fields) if (!fields)
return -1; return -1;
for (uint32_t tidx = 0; tidx < spslr_target_cnt; tidx++) for (spslr_u32 tidx = 0; tidx < spslr_target_cnt; tidx++)
shuffle_target(tidx); shuffle_target(tidx);
return 0; return 0;

16
selfpatch/src/randomizer.h
View File

@ -1,25 +1,25 @@
#ifndef SPSLR_RANDOMIZER_H #ifndef SPSLR_RANDOMIZER_H
#define SPSLR_RANDOMIZER_H #define SPSLR_RANDOMIZER_H
#include <stdint.h> #include "spslr_types.h"
#define SPSLR_RANDOMIZER_FIELD_IDX_MODE_ORIGINAL 1 #define SPSLR_RANDOMIZER_FIELD_IDX_MODE_ORIGINAL 1
#define SPSLR_RANDOMIZER_FIELD_IDX_MODE_FINAL 2 #define SPSLR_RANDOMIZER_FIELD_IDX_MODE_FINAL 2
struct spslr_randomizer_field_info { struct spslr_randomizer_field_info {
uint32_t size; spslr_u32 size;
uint32_t offset; spslr_u32 offset;
uint32_t initial_offset; spslr_u32 initial_offset;
uint32_t alignment; spslr_u32 alignment;
uint32_t flags; spslr_u32 flags;
}; };
int spslr_randomizer_init(); int spslr_randomizer_init();
int spslr_randomize(); int spslr_randomize();
void spslr_randomizer_clear(); void spslr_randomizer_clear();
int spslr_randomizer_get_target(uint32_t target, uint32_t* size, uint32_t* fieldcnt); int spslr_randomizer_get_target(spslr_u32 target, spslr_u32* size, spslr_u32* fieldcnt);
int spslr_randomizer_get_field(uint32_t target, uint32_t field, int field_idx_mode, int spslr_randomizer_get_field(spslr_u32 target, spslr_u32 field, int field_idx_mode,
struct spslr_randomizer_field_info* info); struct spslr_randomizer_field_info* info);
#endif #endif

50
selfpatch/src/selfpatch.c
View File

@ -1,9 +1,7 @@
#include <spslr.h> #include <spslr.h>
#include <stddef.h>
#include "randomizer.h" #include "randomizer.h"
#include "env.h" #include "env.h"
#include "spslr_list_link.h" #include "spslr_list_link.h"
#define SPSLR_SANITY_CHECK #define SPSLR_SANITY_CHECK
@ -11,13 +9,13 @@
static void spslr_selfpatch_load_targets(void); static void spslr_selfpatch_load_targets(void);
static void spslr_selfpatch_randomize_targets(void); static void spslr_selfpatch_randomize_targets(void);
static void spslr_selfpatch_patch_dpins(void); static void spslr_selfpatch_patch_dpins(void);
static void spslr_selfpatch_patch_dpin(void* addr, uint32_t target); static void spslr_selfpatch_patch_dpin(void* addr, spslr_u32 target);
static void spslr_selfpatch_patch_ipins(void); static void spslr_selfpatch_patch_ipins(void);
static void reorder_object(void* dst, const void* src, uint32_t target); static void reorder_object(void* dst, const void* src, spslr_u32 target);
static int64_t spslr_calculate_ipin_value(uint32_t start); static spslr_s64 spslr_calculate_ipin_value(spslr_u32 start);
static void* reorder_buffer = NULL; static void* reorder_buffer = SPSLR_NULL;
static void allocate_reorder_buffer(); static void allocate_reorder_buffer();
static void release_reorder_buffer(); static void release_reorder_buffer();
@ -42,8 +40,8 @@ static void allocate_reorder_buffer() {
if (reorder_buffer) if (reorder_buffer)
return; return;
uint32_t max_target_size = 0; spslr_u32 max_target_size = 0;
for (uint32_t i = 0; i < spslr_target_cnt; i++) { for (spslr_u32 i = 0; i < spslr_target_cnt; i++) {
if (spslr_targets[i].size > max_target_size) if (spslr_targets[i].size > max_target_size)
max_target_size = spslr_targets[i].size; max_target_size = spslr_targets[i].size;
} }
@ -58,25 +56,25 @@ static void release_reorder_buffer() {
return; return;
spslr_env_free(reorder_buffer); spslr_env_free(reorder_buffer);
reorder_buffer = NULL; reorder_buffer = SPSLR_NULL;
} }
static void spslr_selfpatch_patch_dpins(void) { static void spslr_selfpatch_patch_dpins(void) {
for (uint32_t dpidx = 0; dpidx < spslr_dpin_cnt; dpidx++) { for (spslr_u32 dpidx = 0; dpidx < spslr_dpin_cnt; dpidx++) {
const struct spslr_dpin* dp = &spslr_dpins[dpidx]; const struct spslr_dpin* dp = &spslr_dpins[dpidx];
spslr_selfpatch_patch_dpin((void*)dp->addr, dp->target); spslr_selfpatch_patch_dpin((void*)dp->addr, dp->target);
} }
} }
static void reorder_object(void* dst, const void* src, uint32_t target) { static void reorder_object(void* dst, const void* src, spslr_u32 target) {
uint32_t field_count; spslr_u32 field_count;
if (spslr_randomizer_get_target(target, NULL, &field_count)) if (spslr_randomizer_get_target(target, SPSLR_NULL, &field_count))
spslr_env_panic("failed to get target field count"); spslr_env_panic("failed to get target field count");
const uint8_t* src_countable = (const uint8_t*)src; const spslr_u8* src_countable = (const spslr_u8*)src;
uint8_t* dst_countable = (uint8_t*)dst; spslr_u8* dst_countable = (spslr_u8*)dst;
for (uint32_t i = 0; i < field_count; i++) { for (spslr_u32 i = 0; i < field_count; i++) {
struct spslr_randomizer_field_info finfo; struct spslr_randomizer_field_info finfo;
if (spslr_randomizer_get_field(target, i, SPSLR_RANDOMIZER_FIELD_IDX_MODE_FINAL, &finfo)) if (spslr_randomizer_get_field(target, i, SPSLR_RANDOMIZER_FIELD_IDX_MODE_FINAL, &finfo))
spslr_env_panic("failed to get ordered field descriptor"); spslr_env_panic("failed to get ordered field descriptor");
@ -85,7 +83,7 @@ static void reorder_object(void* dst, const void* src, uint32_t target) {
} }
} }
static void spslr_selfpatch_patch_dpin(void* addr, uint32_t target) { static void spslr_selfpatch_patch_dpin(void* addr, spslr_u32 target) {
#ifdef SPSLR_SANITY_CHECK #ifdef SPSLR_SANITY_CHECK
if (target >= spslr_target_cnt) if (target >= spslr_target_cnt)
spslr_env_panic("dpin refers to invalid target"); spslr_env_panic("dpin refers to invalid target");
@ -99,23 +97,23 @@ static void spslr_selfpatch_patch_dpin(void* addr, uint32_t target) {
} }
static void spslr_selfpatch_patch_ipins(void) { static void spslr_selfpatch_patch_ipins(void) {
for (uint32_t ipidx = 0; ipidx < spslr_ipin_cnt; ipidx++) { for (spslr_u32 ipidx = 0; ipidx < spslr_ipin_cnt; ipidx++) {
const struct spslr_ipin* ip = &spslr_ipins[ipidx]; const struct spslr_ipin* ip = &spslr_ipins[ipidx];
int64_t value = spslr_calculate_ipin_value(ip->program); spslr_s64 value = spslr_calculate_ipin_value(ip->program);
switch (ip->size) { switch (ip->size) {
case 1: case 1:
spslr_env_poke_text_8((void*)ip->addr, (uint8_t)value); spslr_env_poke_text_8((void*)ip->addr, (spslr_u8)value);
break; break;
case 2: case 2:
spslr_env_poke_text_16((void*)ip->addr, (uint16_t)value); spslr_env_poke_text_16((void*)ip->addr, (spslr_u16)value);
break; break;
case 4: case 4:
spslr_env_poke_text_32((void*)ip->addr, (uint32_t)value); spslr_env_poke_text_32((void*)ip->addr, (spslr_u32)value);
break; break;
case 8: case 8:
spslr_env_poke_text_64((void*)ip->addr, (uint64_t)value); spslr_env_poke_text_64((void*)ip->addr, (spslr_u64)value);
break; break;
#ifdef SPSLR_SANITY_CHECK #ifdef SPSLR_SANITY_CHECK
default: default:
@ -125,10 +123,10 @@ static void spslr_selfpatch_patch_ipins(void) {
} }
} }
static int64_t spslr_calculate_ipin_value(uint32_t start) { static spslr_s64 spslr_calculate_ipin_value(spslr_u32 start) {
int64_t res = 0; spslr_s64 res = 0;
uint32_t pc = start; spslr_u32 pc = start;
while (true) { while (true) {
#ifdef SPSLR_SANITY_CHECK #ifdef SPSLR_SANITY_CHECK
if (pc >= spslr_ipin_op_cnt) if (pc >= spslr_ipin_op_cnt)

52
selfpatch/src/spslr_list.h
View File

@ -1,7 +1,7 @@
#ifndef SPSLR_LIST_H #ifndef SPSLR_LIST_H
#define SPSLR_LIST_H #define SPSLR_LIST_H
#include <stdint.h> #include "spslr_types.h"
#define __packed __attribute__((packed)) #define __packed __attribute__((packed))
@ -15,49 +15,49 @@
#define SPSLR_FLAG_FIELD_FIXED 1 #define SPSLR_FLAG_FIELD_FIXED 1
struct spslr_target { struct spslr_target {
uint32_t size; spslr_u32 size;
uint32_t fieldcnt; spslr_u32 fieldcnt;
uint32_t fieldoff; // Offset into spslr_target_field array spslr_u32 fieldoff; // Offset into spslr_target_field array
} __packed; } __packed;
struct spslr_target_field { struct spslr_target_field {
uint32_t offset; spslr_u32 offset;
uint32_t size; spslr_u32 size;
uint32_t alignment; spslr_u32 alignment;
uint32_t flags; spslr_u32 flags;
} __packed; } __packed;
struct spslr_ipin { struct spslr_ipin {
uint64_t addr; spslr_u64 addr;
uint32_t size; spslr_u32 size;
uint32_t program; // Index in spslr_ipin_op array spslr_u32 program; // Index in spslr_ipin_op array
} __packed; } __packed;
struct spslr_ipin_op { struct spslr_ipin_op {
uint32_t code; spslr_u32 code;
union { union {
uint32_t patch_unused; spslr_u32 patch_unused;
uint32_t add_initial_offset_target; spslr_u32 add_initial_offset_target;
uint32_t sub_initial_offset_target; spslr_u32 sub_initial_offset_target;
uint32_t add_offset_target; spslr_u32 add_offset_target;
uint32_t sub_offset_target; spslr_u32 sub_offset_target;
int32_t add_const_value; spslr_s32 add_const_value;
} op0; } op0;
union { union {
uint32_t patch_unused; spslr_u32 patch_unused;
uint32_t add_initial_offset_field; spslr_u32 add_initial_offset_field;
uint32_t sub_initial_offset_field; spslr_u32 sub_initial_offset_field;
uint32_t add_offset_field; spslr_u32 add_offset_field;
uint32_t sub_offset_field; spslr_u32 sub_offset_field;
uint32_t add_const_unused; spslr_u32 add_const_unused;
} op1; } op1;
} __packed; } __packed;
struct spslr_dpin { struct spslr_dpin {
uint64_t addr; spslr_u64 addr;
uint32_t target; // Index in spslr_target array spslr_u32 target; // Index in spslr_target array
} __packed; } __packed;
#undef __packed #undef __packed

10
selfpatch/src/spslr_list_link.h
View File

@ -3,19 +3,19 @@
#include "spslr_list.h" #include "spslr_list.h"
extern const uint32_t spslr_target_cnt; extern const spslr_u32 spslr_target_cnt;
extern const struct spslr_target spslr_targets[]; extern const struct spslr_target spslr_targets[];
extern const uint32_t spslr_target_field_cnt; extern const spslr_u32 spslr_target_field_cnt;
extern const struct spslr_target_field spslr_target_fields[]; extern const struct spslr_target_field spslr_target_fields[];
extern const uint32_t spslr_ipin_cnt; extern const spslr_u32 spslr_ipin_cnt;
extern const struct spslr_ipin spslr_ipins[]; extern const struct spslr_ipin spslr_ipins[];
extern const uint32_t spslr_ipin_op_cnt; extern const spslr_u32 spslr_ipin_op_cnt;
extern const struct spslr_ipin_op spslr_ipin_ops[]; extern const struct spslr_ipin_op spslr_ipin_ops[];
extern const uint32_t spslr_dpin_cnt; extern const spslr_u32 spslr_dpin_cnt;
extern const struct spslr_dpin spslr_dpins[]; extern const struct spslr_dpin spslr_dpins[];
#endif #endif

17
selfpatch/src/spslr_types.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef SPSLR_TYPES_H
#define SPSLR_TYPES_H
#include <stdint.h>
#include <stddef.h>
typedef uint8_t spslr_u8;
typedef uint16_t spslr_u16;
typedef uint32_t spslr_u32;
typedef uint64_t spslr_u64;
typedef int32_t spslr_s32;
typedef int64_t spslr_s64;
typedef uintptr_t spslr_uintptr;
#define SPSLR_NULL NULL
#endif