Selfpatch typedefs
This commit is contained in:
parent
2a60879bbb
commit
640cf0d401
@ -13,11 +13,11 @@ static int spslr_env_get_prot(void* addr, int* prot) {
|
||||
if (!f)
|
||||
return -1;
|
||||
|
||||
uintptr_t query = (uintptr_t)addr;
|
||||
spslr_uintptr query = (spslr_uintptr)addr;
|
||||
char line[512];
|
||||
|
||||
while (fgets(line, sizeof(line), f)) {
|
||||
uintptr_t start, end;
|
||||
spslr_uintptr start, end;
|
||||
char perms[5];
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
if (spslr_env_get_prot(dst, &original_prot))
|
||||
spslr_env_panic("failed to get prot of text poke destination");
|
||||
|
||||
uint64_t ptr_uint = (uint64_t)dst;
|
||||
uint64_t ptr_page = ptr_uint & PAGE_MASK;
|
||||
uint64_t prot_size = n + (ptr_uint - ptr_page);
|
||||
spslr_u64 ptr_uint = (spslr_u64)dst;
|
||||
spslr_u64 ptr_page = ptr_uint & PAGE_MASK;
|
||||
spslr_u64 prot_size = n + (ptr_uint - ptr_page);
|
||||
|
||||
int tmp_prot = original_prot | PROT_WRITE;
|
||||
|
||||
@ -68,23 +68,23 @@ void spslr_env_panic(const char* reason) {
|
||||
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));
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
void* spslr_env_malloc(uint32_t n) {
|
||||
void* spslr_env_malloc(spslr_u32 n) {
|
||||
void* res = malloc(n);
|
||||
if (!res)
|
||||
spslr_env_panic("malloc failed");
|
||||
@ -96,26 +96,26 @@ void spslr_env_free(void* 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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
static int rand_initialized = 0;
|
||||
|
||||
uint32_t spslr_env_random_u32() {
|
||||
spslr_u32 spslr_env_random_u32() {
|
||||
if (!rand_initialized) {
|
||||
srand(time(NULL));
|
||||
srand(time(SPSLR_NULL));
|
||||
rand_initialized = 1;
|
||||
}
|
||||
|
||||
return (uint32_t)rand();
|
||||
return (spslr_u32)rand();
|
||||
}
|
||||
|
||||
|
||||
@ -1,18 +1,18 @@
|
||||
#ifndef SPSLR_ENV_H
|
||||
#define SPSLR_ENV_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "spslr_types.h"
|
||||
|
||||
void spslr_env_panic(const char* reason);
|
||||
void spslr_env_poke_text_8(void* dst, uint8_t value);
|
||||
void spslr_env_poke_text_16(void* dst, uint16_t value);
|
||||
void spslr_env_poke_text_32(void* dst, uint32_t value);
|
||||
void spslr_env_poke_text_64(void* dst, uint64_t value);
|
||||
void* spslr_env_malloc(uint32_t n); // Either return valid buffer or panic internally
|
||||
void spslr_env_poke_text_8(void* dst, spslr_u8 value);
|
||||
void spslr_env_poke_text_16(void* dst, spslr_u16 value);
|
||||
void spslr_env_poke_text_32(void* dst, spslr_u32 value);
|
||||
void spslr_env_poke_text_64(void* dst, spslr_u64 value);
|
||||
void* spslr_env_malloc(spslr_u32 n); // Either return valid buffer or panic internally
|
||||
void spslr_env_free(void* ptr);
|
||||
void spslr_env_poke_data(void* dst, const void* src, uint32_t n);
|
||||
void spslr_env_memset(void* dst, int v, uint32_t n);
|
||||
void spslr_env_memcpy(void* dst, const void* src, uint32_t n);
|
||||
uint32_t spslr_env_random_u32();
|
||||
void spslr_env_poke_data(void* dst, const void* src, spslr_u32 n);
|
||||
void spslr_env_memset(void* dst, int v, spslr_u32 n);
|
||||
void spslr_env_memcpy(void* dst, const void* src, spslr_u32 n);
|
||||
spslr_u32 spslr_env_random_u32();
|
||||
|
||||
#endif
|
||||
|
||||
@ -3,12 +3,10 @@
|
||||
#include "spslr_list_link.h"
|
||||
#include "env.h"
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
struct Field {
|
||||
uint32_t 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 */
|
||||
uint32_t fidx; /* Final field idx -> fields[i].fidx = randomized/final position of original field i */
|
||||
spslr_u32 offset; /* Final field offset -> fields[i].offset = offset of field i in final layout */
|
||||
spslr_u32 oidx; /* Original field idx -> fields[i].oidx = original position of field i in final layout */
|
||||
spslr_u32 fidx; /* Final field idx -> fields[i].fidx = randomized/final position of original field i */
|
||||
};
|
||||
|
||||
static struct Field* fields;
|
||||
@ -18,11 +16,11 @@ int spslr_randomizer_init() {
|
||||
if (!fields)
|
||||
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];
|
||||
|
||||
for (uint32_t fidx = 0; fidx < t->fieldcnt; fidx++) {
|
||||
uint32_t gfidx = t->fieldoff + fidx;
|
||||
for (spslr_u32 fidx = 0; fidx < t->fieldcnt; fidx++) {
|
||||
spslr_u32 gfidx = t->fieldoff + fidx;
|
||||
|
||||
const struct spslr_target_field* srcf = &spslr_target_fields[gfidx];
|
||||
struct Field* dstf = &fields[gfidx];
|
||||
@ -41,10 +39,10 @@ void spslr_randomizer_clear() {
|
||||
return;
|
||||
|
||||
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)
|
||||
return -1;
|
||||
|
||||
@ -59,7 +57,7 @@ int spslr_randomizer_get_target(uint32_t target, uint32_t* size, uint32_t* field
|
||||
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) {
|
||||
if (target >= spslr_target_cnt)
|
||||
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)
|
||||
return -1;
|
||||
|
||||
const struct spslr_target_field* of = NULL;
|
||||
const struct Field* rf = NULL;
|
||||
const struct spslr_target_field* of = SPSLR_NULL;
|
||||
const struct Field* rf = SPSLR_NULL;
|
||||
|
||||
switch (field_idx_mode) {
|
||||
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
|
||||
|
||||
struct ShuffleRegion {
|
||||
uint32_t begin;
|
||||
uint32_t end;
|
||||
uint32_t fill_begin;
|
||||
uint32_t fill_end;
|
||||
spslr_u32 begin;
|
||||
spslr_u32 end;
|
||||
spslr_u32 fill_begin;
|
||||
spslr_u32 fill_end;
|
||||
};
|
||||
|
||||
static uint32_t rand_u32(void);
|
||||
static struct Field* get_rfield(uint32_t target, uint32_t final_idx);
|
||||
static const struct spslr_target_field* get_ofield(uint32_t target, uint32_t orig_idx);
|
||||
static void get_origin_region(uint32_t target, uint32_t final_idx, struct ShuffleRegion* region);
|
||||
static int pick_shuffle_option(uint32_t target, uint32_t origin_final_idx,
|
||||
const struct ShuffleRegion* origin, uint32_t alignment, uint32_t* selected);
|
||||
static void do_swap(uint32_t target, uint32_t origin_final_idx,
|
||||
const struct ShuffleRegion* origin_region, uint32_t new_offset);
|
||||
static void shuffle_one_target(uint32_t target);
|
||||
static void shuffle_target(uint32_t target);
|
||||
static spslr_u32 rand_u32(void);
|
||||
static struct Field* get_rfield(spslr_u32 target, spslr_u32 final_idx);
|
||||
static const struct spslr_target_field* get_ofield(spslr_u32 target, spslr_u32 orig_idx);
|
||||
static void get_origin_region(spslr_u32 target, spslr_u32 final_idx, struct ShuffleRegion* region);
|
||||
static int pick_shuffle_option(spslr_u32 target, spslr_u32 origin_final_idx,
|
||||
const struct ShuffleRegion* origin, spslr_u32 alignment, spslr_u32* selected);
|
||||
static void do_swap(spslr_u32 target, spslr_u32 origin_final_idx,
|
||||
const struct ShuffleRegion* origin_region, spslr_u32 new_offset);
|
||||
static void shuffle_one_target(spslr_u32 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();
|
||||
}
|
||||
|
||||
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];
|
||||
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];
|
||||
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 Field* rf = get_rfield(target, final_idx);
|
||||
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_field* origin_of =
|
||||
get_ofield(target, get_rfield(target, origin_final_idx)->oidx);
|
||||
|
||||
// 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)
|
||||
return 0;
|
||||
|
||||
// Field may overlap with origin region. Moving field to offset truly frees:
|
||||
// [true_origin_region_begin, true_origin_region_end)
|
||||
uint32_t true_origin_region_begin = origin->begin;
|
||||
uint32_t true_origin_region_end = origin->end;
|
||||
spslr_u32 true_origin_region_begin = origin->begin;
|
||||
spslr_u32 true_origin_region_end = origin->end;
|
||||
|
||||
if (offset <= origin->fill_begin && option_would_end > true_origin_region_begin)
|
||||
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;
|
||||
|
||||
// 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;
|
||||
for (uint32_t it = 0; it < t->fieldcnt; it++) {
|
||||
spslr_u32 origin_region_ptr = true_origin_region_begin;
|
||||
for (spslr_u32 it = 0; it < t->fieldcnt; it++) {
|
||||
const struct Field* rf = get_rfield(target, it);
|
||||
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;
|
||||
}
|
||||
|
||||
static int pick_shuffle_option(uint32_t target, uint32_t origin_final_idx, const struct ShuffleRegion* origin,
|
||||
uint32_t alignment, uint32_t* selected) {
|
||||
static int pick_shuffle_option(spslr_u32 target, spslr_u32 origin_final_idx, const struct ShuffleRegion* origin,
|
||||
spslr_u32 alignment, spslr_u32* selected) {
|
||||
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))
|
||||
continue;
|
||||
|
||||
@ -230,21 +228,21 @@ static int pick_shuffle_option(uint32_t target, uint32_t origin_final_idx, const
|
||||
return seen ? 0 : -1;
|
||||
}
|
||||
|
||||
static void do_swap(uint32_t target, uint32_t origin_idx,
|
||||
const struct ShuffleRegion* origin_region, uint32_t new_offset) {
|
||||
static void do_swap(spslr_u32 target, spslr_u32 origin_idx,
|
||||
const struct ShuffleRegion* origin_region, spslr_u32 new_offset) {
|
||||
const struct spslr_target* t = &spslr_targets[target];
|
||||
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)
|
||||
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;
|
||||
for (uint32_t it = 0; it < t->fieldcnt; it++) {
|
||||
spslr_u32 origin_region_ptr = true_origin_region_begin;
|
||||
for (spslr_u32 it = 0; it < t->fieldcnt; it++) {
|
||||
struct Field* itf = get_rfield(target, it);
|
||||
|
||||
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)
|
||||
break;
|
||||
|
||||
uint32_t falign = itof->alignment;
|
||||
spslr_u32 falign = itof->alignment;
|
||||
if (origin_region_ptr % falign != 0)
|
||||
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);
|
||||
|
||||
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, origin_idx) = tmp;
|
||||
get_rfield(target, origin_idx)->offset = origin_region_ptr;
|
||||
origin_region_ptr += get_ofield(target, get_rfield(target, origin_idx)->oidx)->size;
|
||||
} 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, origin_idx + (uint32_t)pulled) = tmp;
|
||||
get_rfield(target, origin_idx + (uint32_t)pulled)->offset = origin_region_ptr;
|
||||
origin_region_ptr += get_ofield(target, get_rfield(target, origin_idx + (uint32_t)pulled)->oidx)->size;
|
||||
*get_rfield(target, origin_idx + (spslr_u32)pulled) = tmp;
|
||||
get_rfield(target, origin_idx + (spslr_u32)pulled)->offset = origin_region_ptr;
|
||||
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.
|
||||
*/
|
||||
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);
|
||||
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];
|
||||
if (t->fieldcnt == 0)
|
||||
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);
|
||||
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;
|
||||
|
||||
struct ShuffleRegion origin_region;
|
||||
uint32_t selected_option;
|
||||
spslr_u32 selected_option;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
static void shuffle_target(uint32_t target) {
|
||||
static void shuffle_target(spslr_u32 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);
|
||||
}
|
||||
|
||||
@ -344,7 +342,7 @@ int spslr_randomize() {
|
||||
if (!fields)
|
||||
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);
|
||||
|
||||
return 0;
|
||||
|
||||
@ -1,25 +1,25 @@
|
||||
#ifndef 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_FINAL 2
|
||||
|
||||
struct spslr_randomizer_field_info {
|
||||
uint32_t size;
|
||||
uint32_t offset;
|
||||
uint32_t initial_offset;
|
||||
uint32_t alignment;
|
||||
uint32_t flags;
|
||||
spslr_u32 size;
|
||||
spslr_u32 offset;
|
||||
spslr_u32 initial_offset;
|
||||
spslr_u32 alignment;
|
||||
spslr_u32 flags;
|
||||
};
|
||||
|
||||
int spslr_randomizer_init();
|
||||
int spslr_randomize();
|
||||
void spslr_randomizer_clear();
|
||||
|
||||
int spslr_randomizer_get_target(uint32_t target, uint32_t* size, uint32_t* fieldcnt);
|
||||
int spslr_randomizer_get_field(uint32_t target, uint32_t field, int field_idx_mode,
|
||||
int spslr_randomizer_get_target(spslr_u32 target, spslr_u32* size, spslr_u32* fieldcnt);
|
||||
int spslr_randomizer_get_field(spslr_u32 target, spslr_u32 field, int field_idx_mode,
|
||||
struct spslr_randomizer_field_info* info);
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,9 +1,7 @@
|
||||
#include <spslr.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#include "randomizer.h"
|
||||
#include "env.h"
|
||||
|
||||
#include "spslr_list_link.h"
|
||||
|
||||
#define SPSLR_SANITY_CHECK
|
||||
@ -11,13 +9,13 @@
|
||||
static void spslr_selfpatch_load_targets(void);
|
||||
static void spslr_selfpatch_randomize_targets(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 reorder_object(void* dst, const void* src, uint32_t target);
|
||||
static int64_t spslr_calculate_ipin_value(uint32_t start);
|
||||
static void reorder_object(void* dst, const void* src, spslr_u32 target);
|
||||
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 release_reorder_buffer();
|
||||
@ -42,8 +40,8 @@ static void allocate_reorder_buffer() {
|
||||
if (reorder_buffer)
|
||||
return;
|
||||
|
||||
uint32_t max_target_size = 0;
|
||||
for (uint32_t i = 0; i < spslr_target_cnt; i++) {
|
||||
spslr_u32 max_target_size = 0;
|
||||
for (spslr_u32 i = 0; i < spslr_target_cnt; i++) {
|
||||
if (spslr_targets[i].size > max_target_size)
|
||||
max_target_size = spslr_targets[i].size;
|
||||
}
|
||||
@ -58,25 +56,25 @@ static void release_reorder_buffer() {
|
||||
return;
|
||||
|
||||
spslr_env_free(reorder_buffer);
|
||||
reorder_buffer = NULL;
|
||||
reorder_buffer = SPSLR_NULL;
|
||||
}
|
||||
|
||||
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];
|
||||
spslr_selfpatch_patch_dpin((void*)dp->addr, dp->target);
|
||||
}
|
||||
}
|
||||
|
||||
static void reorder_object(void* dst, const void* src, uint32_t target) {
|
||||
uint32_t field_count;
|
||||
if (spslr_randomizer_get_target(target, NULL, &field_count))
|
||||
static void reorder_object(void* dst, const void* src, spslr_u32 target) {
|
||||
spslr_u32 field_count;
|
||||
if (spslr_randomizer_get_target(target, SPSLR_NULL, &field_count))
|
||||
spslr_env_panic("failed to get target field count");
|
||||
|
||||
const uint8_t* src_countable = (const uint8_t*)src;
|
||||
uint8_t* dst_countable = (uint8_t*)dst;
|
||||
const spslr_u8* src_countable = (const spslr_u8*)src;
|
||||
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;
|
||||
if (spslr_randomizer_get_field(target, i, SPSLR_RANDOMIZER_FIELD_IDX_MODE_FINAL, &finfo))
|
||||
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
|
||||
if (target >= spslr_target_cnt)
|
||||
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) {
|
||||
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];
|
||||
|
||||
int64_t value = spslr_calculate_ipin_value(ip->program);
|
||||
spslr_s64 value = spslr_calculate_ipin_value(ip->program);
|
||||
|
||||
switch (ip->size) {
|
||||
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;
|
||||
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;
|
||||
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;
|
||||
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;
|
||||
#ifdef SPSLR_SANITY_CHECK
|
||||
default:
|
||||
@ -125,10 +123,10 @@ static void spslr_selfpatch_patch_ipins(void) {
|
||||
}
|
||||
}
|
||||
|
||||
static int64_t spslr_calculate_ipin_value(uint32_t start) {
|
||||
int64_t res = 0;
|
||||
static spslr_s64 spslr_calculate_ipin_value(spslr_u32 start) {
|
||||
spslr_s64 res = 0;
|
||||
|
||||
uint32_t pc = start;
|
||||
spslr_u32 pc = start;
|
||||
while (true) {
|
||||
#ifdef SPSLR_SANITY_CHECK
|
||||
if (pc >= spslr_ipin_op_cnt)
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#ifndef SPSLR_LIST_H
|
||||
#define SPSLR_LIST_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "spslr_types.h"
|
||||
|
||||
#define __packed __attribute__((packed))
|
||||
|
||||
@ -15,49 +15,49 @@
|
||||
#define SPSLR_FLAG_FIELD_FIXED 1
|
||||
|
||||
struct spslr_target {
|
||||
uint32_t size;
|
||||
uint32_t fieldcnt;
|
||||
uint32_t fieldoff; // Offset into spslr_target_field array
|
||||
spslr_u32 size;
|
||||
spslr_u32 fieldcnt;
|
||||
spslr_u32 fieldoff; // Offset into spslr_target_field array
|
||||
} __packed;
|
||||
|
||||
struct spslr_target_field {
|
||||
uint32_t offset;
|
||||
uint32_t size;
|
||||
uint32_t alignment;
|
||||
uint32_t flags;
|
||||
spslr_u32 offset;
|
||||
spslr_u32 size;
|
||||
spslr_u32 alignment;
|
||||
spslr_u32 flags;
|
||||
} __packed;
|
||||
|
||||
struct spslr_ipin {
|
||||
uint64_t addr;
|
||||
uint32_t size;
|
||||
uint32_t program; // Index in spslr_ipin_op array
|
||||
spslr_u64 addr;
|
||||
spslr_u32 size;
|
||||
spslr_u32 program; // Index in spslr_ipin_op array
|
||||
} __packed;
|
||||
|
||||
struct spslr_ipin_op {
|
||||
uint32_t code;
|
||||
spslr_u32 code;
|
||||
|
||||
union {
|
||||
uint32_t patch_unused;
|
||||
uint32_t add_initial_offset_target;
|
||||
uint32_t sub_initial_offset_target;
|
||||
uint32_t add_offset_target;
|
||||
uint32_t sub_offset_target;
|
||||
int32_t add_const_value;
|
||||
spslr_u32 patch_unused;
|
||||
spslr_u32 add_initial_offset_target;
|
||||
spslr_u32 sub_initial_offset_target;
|
||||
spslr_u32 add_offset_target;
|
||||
spslr_u32 sub_offset_target;
|
||||
spslr_s32 add_const_value;
|
||||
} op0;
|
||||
|
||||
union {
|
||||
uint32_t patch_unused;
|
||||
uint32_t add_initial_offset_field;
|
||||
uint32_t sub_initial_offset_field;
|
||||
uint32_t add_offset_field;
|
||||
uint32_t sub_offset_field;
|
||||
uint32_t add_const_unused;
|
||||
spslr_u32 patch_unused;
|
||||
spslr_u32 add_initial_offset_field;
|
||||
spslr_u32 sub_initial_offset_field;
|
||||
spslr_u32 add_offset_field;
|
||||
spslr_u32 sub_offset_field;
|
||||
spslr_u32 add_const_unused;
|
||||
} op1;
|
||||
} __packed;
|
||||
|
||||
struct spslr_dpin {
|
||||
uint64_t addr;
|
||||
uint32_t target; // Index in spslr_target array
|
||||
spslr_u64 addr;
|
||||
spslr_u32 target; // Index in spslr_target array
|
||||
} __packed;
|
||||
|
||||
#undef __packed
|
||||
|
||||
@ -3,19 +3,19 @@
|
||||
|
||||
#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 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 uint32_t spslr_ipin_cnt;
|
||||
extern const spslr_u32 spslr_ipin_cnt;
|
||||
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 uint32_t spslr_dpin_cnt;
|
||||
extern const spslr_u32 spslr_dpin_cnt;
|
||||
extern const struct spslr_dpin spslr_dpins[];
|
||||
|
||||
#endif
|
||||
|
||||
17
selfpatch/src/spslr_types.h
Normal file
17
selfpatch/src/spslr_types.h
Normal 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
|
||||
Loading…
Reference in New Issue
Block a user