Emulator-Archive/box64
1
0
Fork 0
mirror of https://github.com/ptitSeb/box64.git synced 2025-02-18 13:29:44 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Attempt to embrace memory malloc (not working, malloc override comes too late)

Browse Source
This commit is contained in:
ptitSeb 2022-09-15 12:13:39 +02:00
parent 0b12343ed0
commit 4b22630943
2 changed files with 26 additions and 529 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/main.c
View File

@ -1476,6 +1476,9 @@ int main(int argc, const char **argv, char **env) {
}
// and handle PLT
RelocateElfPlt(my_context->maplib, NULL, 0, elf_header);
// enable custom malloc if it was hooked
extern int go_hooking_malloc;
go_hooking_malloc = 1;
// defered init
RunDeferedElfInit(emu);
// update TLS of main elf

552
src/mallochook.c
View File

@ -38,13 +38,6 @@
*/
//#define EMBRACE
#ifndef EMBRACE
#include "bridge.h"
#include "tools/bridge_private.h"
#include "wrapper.h"
#endif
#define SUPER() \
GO(malloc, pFL); \
@ -58,35 +51,6 @@ GO(pvalloc, pFL); \
GO(valloc, pFL); \
GO(cfree, vFp); \
GO(malloc_usable_size, LFp) ; \
GO2(_Znwm, pFL); \
GO2(_ZnwmRKSt9nothrow_t, pFLp); \
GO2(_Znam, pFL); \
GO2(_ZnamRKSt9nothrow_t, pFLp); \
GO2(_ZdaPv, vFp); \
GO2(_ZdaPvm, vFpL); \
GO2(_ZdaPvmSt11align_val_t, vFpLL); \
GO2(_ZdlPv, vFp); \
GO2(_ZdlPvm, vFpL); \
GO2(_ZnwmSt11align_val_t, pFLL); \
GO2(_ZnwmSt11align_val_tRKSt9nothrow_t, pFLLp); \
GO2(_ZnamSt11align_val_t, pFLL); \
GO2(_ZnamSt11align_val_tRKSt9nothrow_t, pFLLp); \
GO2(_ZdlPvRKSt9nothrow_t, vFpp); \
GO2(_ZdaPvSt11align_val_tRKSt9nothrow_t, vFpLp);\
GO2(_ZdlPvmSt11align_val_t, vFpLL); \
GO2(_ZdaPvRKSt9nothrow_t, vFpp); \
GO2(_ZdaPvSt11align_val_t, vFpL); \
GO2(_ZdlPvSt11align_val_t, vFpL); \
GO2(_ZdlPvSt11align_val_tRKSt9nothrow_t, vFpLp);\
GO2(tc_calloc, pFLL); \
GO2(tc_cfree, vFp); \
GO2(tc_delete, vFp); \
GO2(tc_deletearray, vFp); \
GO2(tc_deletearray_nothrow, vFpp); \
GO2(tc_delete_nothrow, vFpp); \
GO2(tc_free, vFp); \
GO2(tc_malloc, pFL); \
GO2(tc_malloc_size, LFp); \
typedef void* (*pFL_t) (size_t);
typedef void* (*pFLp_t) (size_t, void* p);
@ -109,13 +73,13 @@ void*(*__libc_memalign)(size_t, size_t) = NULL;
#endif
size_t(*box_malloc_usable_size)(void*) = NULL;
#define GO(A, B)
#define GO2(A, B) B##_t box_##A = NULL
SUPER()
#undef GO2
#undef GO
int GetTID();
int go_hooking_malloc = 0;
char* box_strdup(const char* s) {
char* ret = box_calloc(1, strlen(s)+1);
memcpy(ret, s, strlen(s));
@ -140,18 +104,13 @@ char* box_realpath(const char* path, char* ret)
return box_strdup(tmp);
}
#ifdef EMBRACE
// emulated lib/program hooked memory functions
#define GO(A, B) uintptr_t hooked_##A = 0
#define GO2(A, B) uintptr_t hooked_##A = 0
SUPER()
#undef GO
#undef GO2
#define GO(A, B) elfheader_t* elf_##A = NULL
#define GO2(A, B) elfheader_t* elf_##A = NULL
SUPER()
#undef GO
#endif
static size_t pot(size_t l) {
size_t ret = 0;
@ -162,79 +121,71 @@ static size_t pot(size_t l) {
// redefining all libc memory allocation routines
EXPORT void* malloc(size_t l)
{
#ifdef EMBRACE
if(hooked_malloc && elf_malloc && elf_malloc->init_done) {
if(hooked_malloc && elf_malloc && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated malloc(%zd)\n", GetTID(), l);
void* ret = (void*)RunSafeFunction(my_context, hooked_malloc, 1, l);
return ret;
}
#endif
return box_calloc(1, l);
void* ret = box_calloc(1, l);
if(my_context) printf_log(LOG_DEBUG, "native malloc(%zu) => %p\n", l, ret);
return ret;
}
EXPORT void free(void* p)
{
#ifdef EMBRACE
if(hooked_free && elf_free && elf_free->init_done) {
if(hooked_free && elf_free && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated free(%x)\n", GetTID(), p);
RunSafeFunction(my_context, hooked_free, 1, p);
} else
#endif
box_free(p);
}
EXPORT void* calloc(size_t n, size_t s)
{
#ifdef EMBRACE
if(hooked_calloc && elf_calloc && elf_calloc->init_done) {
if(hooked_calloc && elf_calloc && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated calloc(%zd, %zd)\n", GetTID(), n, s);
return (void*)RunSafeFunction(my_context, hooked_calloc, 2, n, s);
}
#endif
return box_calloc(n, s);
void* ret = box_calloc(n, s);
if(my_context) printf_log(LOG_DEBUG, "native calloc(%zu, %zu) => %p\n", n, s, ret);
return ret;
}
EXPORT void* realloc(void* p, size_t s)
{
#ifdef EMBRACE
if(hooked_realloc && elf_realloc && elf_realloc->init_done) {
if(hooked_realloc && elf_realloc && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated realloc(%p, %zd)\n", GetTID(), p, s);
return (void*)RunSafeFunction(my_context, hooked_realloc, 2, p, s);
}
#endif
return box_realloc(p, s);
void* ret = box_realloc(p, s);
if(my_context) printf_log(LOG_DEBUG, "native realloc(%p, %zu) => %p\n", p, s, ret);
return ret;
}
EXPORT void* aligned_alloc(size_t align, size_t size)
{
#ifdef EMBRACE
if(hooked_aligned_alloc && elf_aligned_alloc && elf_aligned_alloc->init_done) {
if(hooked_aligned_alloc && elf_aligned_alloc && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated aligned_alloc(%zd, %zd)\n", GetTID(), align, size);
return (void*)RunSafeFunction(my_context, hooked_aligned_alloc, 2, align, size);
}
#endif
return box_memalign(align, size);
}
EXPORT void* memalign(size_t align, size_t size)
{
#ifdef EMBRACE
if(hooked_memalign && elf_memalign && elf_memalign->init_done) {
if(hooked_memalign && elf_memalign && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated memalign(%zd, %zd)\n", GetTID(), align, size);
return (void*)RunSafeFunction(my_context, hooked_memalign, 2, align, size);
}
#endif
return box_memalign(align, size);
}
EXPORT int posix_memalign(void** p, size_t align, size_t size)
{
#ifdef EMBRACE
if(hooked_posix_memalign && elf_posix_memalign && elf_posix_memalign->init_done) {
if(hooked_posix_memalign && elf_posix_memalign && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated posix_memalign(%p, %zd, %zd)\n", GetTID(), p, align, size);
return (int)RunSafeFunction(my_context, hooked_posix_memalign, 3, p, align, size);
}
#endif
if(align%sizeof(void*) || pot(align)!=align)
return EINVAL;
void* ret = box_memalign(align, size);
@ -246,477 +197,42 @@ EXPORT int posix_memalign(void** p, size_t align, size_t size)
EXPORT void* valloc(size_t size)
{
#ifdef EMBRACE
if(hooked_valloc && elf_valloc && elf_valloc->init_done) {
if(hooked_valloc && elf_valloc && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated valloc(%zd)\n", GetTID(), size);
return (void*)RunSafeFunction(my_context, hooked_valloc, 1, size);
}
#endif
return box_memalign(box64_pagesize, size);
}
EXPORT void* pvalloc(size_t size)
{
#ifdef EMBRACE
if(hooked_pvalloc && elf_pvalloc && elf_pvalloc->init_done) {
if(hooked_pvalloc && elf_pvalloc && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated pvalloc(%zd)\n", GetTID(), size);
return (void*)RunSafeFunction(my_context, hooked_pvalloc, 1, size);
}
#endif
return box_memalign(box64_pagesize, (size+box64_pagesize-1)&~(box64_pagesize-1));
}
EXPORT void cfree(void* p)
{
#ifdef EMBRACE
if(hooked_cfree && elf_cfree && elf_cfree->init_done) {
if(hooked_cfree && elf_cfree && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated cfree(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked_cfree, 1, p);
} else
#endif
box_free(p);
}
EXPORT size_t malloc_usable_size(void* p)
{
#ifdef EMBRACE
if(hooked_malloc_usable_size && elf_malloc_usable_size && elf_malloc_usable_size->init_done) {
if(hooked_malloc_usable_size && elf_malloc_usable_size && go_hooking_malloc) {
printf_log(LOG_DEBUG, "%04d|emulated malloc_usable_size(%p)\n", GetTID(), p);
return (size_t)RunSafeFunction(my_context, hooked_malloc_usable_size, 1, p);
} else
#endif
return box_malloc_usable_size(p);
}
EXPORT void* my__Znwm(size_t sz) //operator new(size_t)
{
#ifdef EMBRACE
if(hooked__Znwm && elf__Znwm && elf__Znwm->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _Znwm(%zu)\n", GetTID(), sz);
return (void*)RunSafeFunction(my_context, hooked__Znwm, 1, sz);
} else
#endif
if(box__Znwm)
return box__Znwm(sz);
else
return box_malloc(sz);
}
EXPORT void* my__ZnwmRKSt9nothrow_t(size_t sz, void* p) //operator new(size_t, std::nothrow_t const&)
{
#ifdef EMBRACE
if(hooked__ZnwmRKSt9nothrow_t && elf__ZnwmRKSt9nothrow_t && elf__ZnwmRKSt9nothrow_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZnwmRKSt9nothrow_t(%p)\n", GetTID(), p);
return (void*)RunSafeFunction(my_context, hooked__ZnwmRKSt9nothrow_t, 2, sz, p);
} else
#endif
if(box__ZnwmRKSt9nothrow_t)
return box__ZnwmRKSt9nothrow_t(sz, p);
else
return box_malloc(sz);
}
EXPORT void* my__Znam(size_t sz) //operator new[](size_t)
{
#ifdef EMBRACE
if(hooked__Znam && elf__Znam && elf__Znam->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _Znam(%zu)\n", GetTID(), sz);
return (void*)RunSafeFunction(my_context, hooked__Znam, 1, sz);
} else
#endif
if(box__Znam)
return box__Znam(sz);
else
return box_malloc(sz);
}
EXPORT void* my__ZnamRKSt9nothrow_t(size_t sz, void* p) //operator new[](size_t, std::nothrow_t const&)
{
#ifdef EMBRACE
if(hooked__ZnamRKSt9nothrow_t && elf__ZnamRKSt9nothrow_t && elf__ZnamRKSt9nothrow_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZnamRKSt9nothrow_t(%p)\n", GetTID(), p);
return (void*)RunSafeFunction(my_context, hooked__ZnamRKSt9nothrow_t, 2, sz, p);
} else
#endif
if(box__ZnamRKSt9nothrow_t)
return box__ZnamRKSt9nothrow_t(sz, p);
return box_malloc(sz);
}
EXPORT void my__ZdaPv(void* p) //operator delete[](void*)
{
#ifdef EMBRACE
if(hooked__ZdaPv && elf__ZdaPv && elf__ZdaPv->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdaPv(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdaPv, 1, p);
} else
#endif
if(box__ZdaPv)
box__ZdaPv(p);
else
box_free(p);
}
EXPORT void my__ZdaPvm(void* p, size_t sz) //operator delete[](void*, size_t)
{
#ifdef EMBRACE
if(hooked__ZdaPvm && elf__ZdaPvm && elf__ZdaPvm->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdaPvm(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdaPvm, 2, p, sz);
} else
#endif
if(box__ZdaPvm)
box__ZdaPvm(p, sz);
else
box_free(p);
}
EXPORT void my__ZdaPvmSt11align_val_t(void* p, size_t sz, size_t align) //operator delete[](void*, unsigned long, std::align_val_t)
{
#ifdef EMBRACE
if(hooked__ZdaPvmSt11align_val_t && elf__ZdaPvmSt11align_val_t && elf__ZdaPvmSt11align_val_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdaPvmSt11align_val_t(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdaPvmSt11align_val_t, 3, p, sz, align);
} else
#endif
if(box__ZdaPvmSt11align_val_t)
box__ZdaPvmSt11align_val_t(p, sz, align);
else
box_free(p);
}
EXPORT void my__ZdlPv(void* p) //operator delete(void*)
{
#ifdef EMBRACE
if(hooked__ZdlPv && elf__ZdlPv && elf__ZdlPv->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdlPv(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdlPv, 1, p);
} else
#endif
if(box__ZdlPv)
box__ZdlPv(p);
else
box_free(p);
}
EXPORT void my__ZdlPvm(void* p, size_t sz) //operator delete(void*, size_t)
{
#ifdef EMBRACE
if(hooked__ZdlPvm && elf__ZdlPvm && elf__ZdlPvm->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdlPvm(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdlPvm, 2, p, sz);
} else
#endif
if(box__ZdlPvm)
box__ZdlPvm(p, sz);
else
box_free(p);
}
EXPORT void* my__ZnwmSt11align_val_t(size_t sz, size_t align) //// operator new(unsigned long, std::align_val_t)
{
#ifdef EMBRACE
if(hooked__ZnwmSt11align_val_t && elf__ZnwmSt11align_val_t && elf__ZnwmSt11align_val_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZnwmSt11align_val_t(%zu, %zu)\n", GetTID(), sz, align);
return (void*)RunSafeFunction(my_context, hooked__ZnwmSt11align_val_t, 2, sz, align);
} else
#endif
if(box__ZnwmSt11align_val_t)
return box__ZnwmSt11align_val_t(sz, align);
else
return box_memalign(align, sz);
}
EXPORT void* my__ZnwmSt11align_val_tRKSt9nothrow_t(size_t sz, size_t align, void* p) //// operator new(unsigned long, std::align_val_t, std::nothrow_t const&)
{
#ifdef EMBRACE
if(hooked__ZnwmSt11align_val_tRKSt9nothrow_t && elf__ZnwmSt11align_val_tRKSt9nothrow_t && elf__ZnwmSt11align_val_tRKSt9nothrow_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZnwmSt11align_val_tRKSt9nothrow_t(%zu, %zu, %p)\n", GetTID(), sz, align, p);
return (void*)RunSafeFunction(my_context, hooked__ZnwmSt11align_val_tRKSt9nothrow_t, 3, sz, align, p);
} else
#endif
if(box__ZnwmSt11align_val_tRKSt9nothrow_t)
return box__ZnwmSt11align_val_tRKSt9nothrow_t(sz, align, p);
else
return box_memalign(align, sz);
}
EXPORT void* my__ZnamSt11align_val_t(size_t sz, size_t align) //// operator new[](unsigned long, std::align_val_t)
{
#ifdef EMBRACE
if(hooked__ZnamSt11align_val_t && elf__ZnamSt11align_val_t && elf__ZnamSt11align_val_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZnamSt11align_val_t(%zu, %zu)\n", GetTID(), sz, align);
return (void*)RunSafeFunction(my_context, hooked__ZnamSt11align_val_t, 2, sz, align);
} else
#endif
if(box__ZnamSt11align_val_t)
return box__ZnamSt11align_val_t(sz, align);
else
return box_memalign(align, sz);
}
EXPORT void* my__ZnamSt11align_val_tRKSt9nothrow_t(size_t sz, size_t align, void* p) //// operator new[](unsigned long, std::align_val_t, std::nothrow_t const&)
{
#ifdef EMBRACE
if(hooked__ZnamSt11align_val_tRKSt9nothrow_t && elf__ZnamSt11align_val_tRKSt9nothrow_t && elf__ZnamSt11align_val_tRKSt9nothrow_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZnamSt11align_val_tRKSt9nothrow_t(%zu, %zu, %p)\n", GetTID(), sz, align, p);
return (void*)RunSafeFunction(my_context, hooked__ZnamSt11align_val_tRKSt9nothrow_t, 3, sz, align, p);
} else
#endif
if(box__ZnamSt11align_val_tRKSt9nothrow_t)
return box__ZnamSt11align_val_tRKSt9nothrow_t(sz, align, p);
else
return box_memalign(align, sz);
}
EXPORT void my__ZdlPvRKSt9nothrow_t(void* p, void* n) //operator delete(void*, std::nothrow_t const&)
{
#ifdef EMBRACE
if(hooked__ZdlPvRKSt9nothrow_t && elf__ZdlPvRKSt9nothrow_t && elf__ZdlPvRKSt9nothrow_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdlPvRKSt9nothrow_t(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdlPvRKSt9nothrow_t, 2, p, n);
} else
#endif
if(box__ZdlPvRKSt9nothrow_t)
box__ZdlPvRKSt9nothrow_t(p, n);
else
box_free(p);
}
EXPORT void my__ZdaPvSt11align_val_tRKSt9nothrow_t(void* p, size_t align, void* n) //operator delete[](void*, std::align_val_t, std::nothrow_t const&)
{
#ifdef EMBRACE
if(hooked__ZdaPvSt11align_val_tRKSt9nothrow_t && elf__ZdaPvSt11align_val_tRKSt9nothrow_t && elf__ZdaPvSt11align_val_tRKSt9nothrow_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdaPvSt11align_val_tRKSt9nothrow_t(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdaPvSt11align_val_tRKSt9nothrow_t, 3, p, align, n);
} else
#endif
if(box__ZdaPvSt11align_val_tRKSt9nothrow_t)
box__ZdaPvSt11align_val_tRKSt9nothrow_t(p, align, n);
else
box_free(p);
}
EXPORT void my__ZdlPvmSt11align_val_t(void* p, size_t sz, size_t align) //operator delete(void*, unsigned long, std::align_val_t)
{
#ifdef EMBRACE
if(hooked__ZdlPvmSt11align_val_t && elf__ZdlPvmSt11align_val_t && elf__ZdlPvmSt11align_val_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdlPvmSt11align_val_t(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdlPvmSt11align_val_t, 3, p, sz, align);
} else
#endif
if(box__ZdlPvmSt11align_val_t)
box__ZdlPvmSt11align_val_t(p, sz, align);
else
box_free(p);
}
EXPORT void my__ZdaPvRKSt9nothrow_t(void* p, void* n) //operator delete[](void*, std::nothrow_t const&)
{
#ifdef EMBRACE
if(hooked__ZdaPvRKSt9nothrow_t && elf__ZdaPvRKSt9nothrow_t && elf__ZdaPvRKSt9nothrow_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdaPvRKSt9nothrow_t(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdaPvRKSt9nothrow_t, 2, p, n);
} else
#endif
if(box__ZdaPvRKSt9nothrow_t)
box__ZdaPvRKSt9nothrow_t(p, n);
else
box_free(p);
}
EXPORT void my__ZdaPvSt11align_val_t(void* p, size_t align) //operator delete[](void*, std::align_val_t)
{
#ifdef EMBRACE
if(hooked__ZdaPvSt11align_val_t && elf__ZdaPvSt11align_val_t && elf__ZdaPvSt11align_val_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdaPvSt11align_val_t(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdaPvSt11align_val_t, 2, p, align);
} else
#endif
if(box__ZdaPvSt11align_val_t)
box__ZdaPvSt11align_val_t(p, align);
else
box_free(p);
}
EXPORT void my__ZdlPvSt11align_val_t(void* p, size_t align) //operator delete(void*, std::align_val_t)
{
#ifdef EMBRACE
if(hooked__ZdlPvSt11align_val_t && elf__ZdlPvSt11align_val_t && elf__ZdlPvSt11align_val_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdlPvSt11align_val_t(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdlPvSt11align_val_t, 2, p, align);
} else
#endif
if(box__ZdlPvSt11align_val_t)
box__ZdlPvSt11align_val_t(p, align);
else
box_free(p);
}
EXPORT void my__ZdlPvSt11align_val_tRKSt9nothrow_t(void* p, size_t align, void* n) //operator delete(void*, std::align_val_t, std::nothrow_t const&)
{
#ifdef EMBRACE
if(hooked__ZdlPvSt11align_val_tRKSt9nothrow_t && elf__ZdlPvSt11align_val_tRKSt9nothrow_t && elf__ZdlPvSt11align_val_tRKSt9nothrow_t->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated _ZdlPvSt11align_val_tRKSt9nothrow_t(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked__ZdlPvSt11align_val_tRKSt9nothrow_t, 3, p, align, n);
} else
#endif
if(box__ZdlPvSt11align_val_tRKSt9nothrow_t)
box__ZdlPvSt11align_val_tRKSt9nothrow_t(p, align, n);
else
box_free(p);
}
EXPORT void* my_tc_calloc(size_t n, size_t s)
{
#ifdef EMBRACE
if(hooked_tc_calloc && elf_tc_calloc && elf_tc_calloc->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated tc_calloc(%zd, %zd)\n", GetTID(), n, s);
return (void*)RunSafeFunction(my_context, hooked_tc_calloc, 2, n, s);
}
#endif
if(box_tc_calloc)
return box_tc_calloc(n, s);
else
return box_calloc(n, s);
}
EXPORT void my_tc_cfree(void* p)
{
#ifdef EMBRACE
if(hooked_tc_cfree && elf_tc_cfree && elf_tc_cfree->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated tc_cfree(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked_tc_cfree, 1, p);
} else
#endif
if(box_tc_cfree)
box_tc_cfree(p);
else
box_free(p);
}
EXPORT void my_tc_delete(void* p)
{
#ifdef EMBRACE
if(hooked_tc_delete && elf_tc_delete && elf_tc_delete->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated tc_delete(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked_tc_delete, 1, p);
} else
#endif
if(box_tc_delete)
box_tc_delete(p);
else
box_free(p);
}
EXPORT void my_tc_deletearray(void* p)
{
#ifdef EMBRACE
if(hooked_tc_deletearray && elf_tc_deletearray && elf_tc_deletearray->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated tc_deletearray(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked_tc_deletearray, 1, p);
} else
#endif
if(box_tc_deletearray)
box_tc_deletearray(p);
else
box_free(p);
}
EXPORT void my_tc_deletearray_nothrow(void* p, void* n)
{
#ifdef EMBRACE
if(hooked_tc_deletearray_nothrow && elf_tc_deletearray_nothrow && elf_tc_deletearray_nothrow->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated tc_deletearray_nothrow(%p, %p)\n", GetTID(), p, n);
RunSafeFunction(my_context, hooked_tc_deletearray_nothrow, 2, p, n);
} else
#endif
if(box_tc_deletearray_nothrow)
box_tc_deletearray_nothrow(p, n);
else
box_free(p);
}
EXPORT void my_tc_delete_nothrow(void* p, void* n)
{
#ifdef EMBRACE
if(hooked_tc_delete_nothrow && elf_tc_delete_nothrow && elf_tc_delete_nothrow->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated tc_delete_nothrow(%p, %p)\n", GetTID(), p, n);
RunSafeFunction(my_context, hooked_tc_delete_nothrow, 2, p, n);
} else
#endif
if(box_tc_delete_nothrow)
box_tc_delete_nothrow(p, n);
else
box_free(p);
}
EXPORT void my_tc_free(void* p)
{
#ifdef EMBRACE
if(hooked_tc_free && elf_tc_free && elf_tc_free->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated tc_free(%p)\n", GetTID(), p);
RunSafeFunction(my_context, hooked_tc_free, 1, p);
} else
#endif
if(box_tc_free)
box_tc_free(p);
else
box_free(p);
}
EXPORT void* my_tc_malloc(size_t s)
{
#ifdef EMBRACE
if(hooked_tc_malloc && elf_tc_malloc && elf_tc_malloc->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated tc_malloc(%zd)\n", GetTID(), s);
return (void*)RunSafeFunction(my_context, hooked_tc_malloc, 1, s);
}
#endif
if(box_tc_malloc)
return box_tc_malloc(s);
else
return box_calloc(1, s);
}
EXPORT size_t my_tc_malloc_size(void* p)
{
#ifdef EMBRACE
if(hooked_tc_malloc_size && elf_tc_malloc_size && elf_tc_malloc_size->init_done) {
printf_log(LOG_DEBUG, "%04d|emulated tc_malloc_size(%p)\n", GetTID(), p);
return (size_t)RunSafeFunction(my_context, hooked_tc_malloc_size, 1, p);
}
#endif
if(box_tc_malloc_size)
return box_tc_malloc_size(p);
else
return box_malloc_usable_size(p);
}
#pragma pack(push, 1)
typedef struct reloc_jmp_s {
uint8_t _ff;
uint8_t _25;
uint32_t _00;
void* addr;
} reloc_jmp_t;
#pragma pack(pop)
static void addRelocJmp(void* offs, void* where)
{
reloc_jmp_t jmp = {0};
jmp._ff = 0xff;
jmp._25 = 0x25;
jmp.addr = where;
memcpy(offs, &jmp, sizeof(jmp));
}
void checkHookedSymbols(lib_t *maplib, elfheader_t* h)
{
#ifndef EMBRACE
static int hooked = 0;
#endif
for (size_t i=0; i<h->numDynSym; ++i) {
const char * symname = h->DynStr+h->DynSym[i].st_name;
int bind = ELF64_ST_BIND(h->DynSym[i].st_info);
@ -726,25 +242,10 @@ void checkHookedSymbols(lib_t *maplib, elfheader_t* h)
&& (vis==STV_DEFAULT || vis==STV_PROTECTED) && (h->DynSym[i].st_shndx!=0 && h->DynSym[i].st_shndx<=65521)) {
uintptr_t offs = h->DynSym[i].st_value + h->delta;
size_t sz = h->DynSym[i].st_size;
if(bind!=STB_LOCAL && bind!=STB_WEAK && sz>=sizeof(reloc_jmp_t)) {
#ifdef EMBRACE
if(bind!=STB_LOCAL && bind!=STB_WEAK) {
#define GO(A, B) if (!hooked_##A && !strcmp(symname, #A)) {hooked_##A = offs; elf_##A = h; if(hooked_##A) printf_log(LOG_INFO, "Overriding %s to %p (%s)\n", #A, (void*)hooked_##A, h->name);}
#define GO2(A, B) if (!hooked_##A &&hooked_malloc && !strcmp(symname, #A)) {hooked_##A = offs; elf_##A = h; if(hooked_##A) printf_log(LOG_INFO, "Overriding %s to %p (%s)\n", #A, (void*)hooked_##A, h->name);}
#else
#define GO(A, B) if(!strcmp(symname, "__libc_" #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, A, 0, #A); printf_log(LOG_INFO, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt);}
#define GO2(A, B)
SUPER()
#undef GO
#define GO(A, B) if(!strcmp(symname, "tc_" #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, A, 0, #A); printf_log(LOG_INFO, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt);}
SUPER()
#undef GO
#undef GO2
#define GO(A, B) if(!strcmp(symname, #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, A, 0, #A); hooked=1; printf_log(LOG_INFO, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt);}
#define GO2(A, B) if(hooked && !strcmp(symname, #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, my_##A, 0, #A); printf_log(LOG_INFO, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt);}
#endif
SUPER()
#undef GO
#undef GO2
}
}
}
@ -759,13 +260,6 @@ void init_malloc_hook() {
__libc_memalign = dlsym(RTLD_NEXT, "memalign");
#endif
box_malloc_usable_size = dlsym(RTLD_NEXT, "malloc_usable_size");
#if 0
#define GO(A, B)
#define GO2(A, B) box_##A = (B##_t)dlsym(RTLD_NEXT, #A); if(box_##A == (B##_t)A) box_##A = NULL;
SUPER()
#undef GO2
#undef GO
#endif
}
#undef SUPER