lorenz.stechauner/BSc-Thesis
1
0
Fork 0
Code Activity

proj: Implement InterruptedCheckTester

Browse Source
This commit is contained in:
Lorenz Stechauner
2025-02-17 20:15:01 +01:00
parent cc2b270d8f
commit 3db8439a9b
4 changed files with 229 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

231
proj/server/src/intercept.py
View File

@@ -19,13 +19,13 @@ class ThreadedUnixStreamServer(ThreadingMixIn, UnixStreamServer):
class Handler(StreamRequestHandler):
pid: int
stack: list[tuple[str, tuple]]
stack: list[tuple[int, str, tuple]]
ret_addr: int
def before(self) -> None:
pass
def after(self) -> None:
pass
def before(self) -> None: pass
def after(self) -> None: pass
def before_fallback(self, func_name: str, *args) -> str: pass
def after_fallback(self, func_name: str, *args, **kwargs) -> None: pass
def handle(self):
first = self.rfile.readline()
@@ -93,7 +93,7 @@ class Handler(StreamRequestHandler):
idx = len(m.group(0))
if a.startswith('0x'):
val = int(a[2:], 16)
elif a.startswith('0'):
elif a.startswith('0') and len(a) > 1:
val = int(a[1:], 8)
else:
val = int(a, 10)
@@ -157,68 +157,131 @@ class Handler(StreamRequestHandler):
call = data.decode('utf-8')
print(f'[{self.pid}] {call}')
func_name = call[:call.find('(')]
args, _ = Handler.parse_args(call[call.find('(') + 1:-1])
self.stack.append((func_name, args))
self.ret_addr = int(call[call.rfind(':') + 1:], 0)
args, _ = Handler.parse_args(call[call.find('(') + 1:call.rfind(':') - 1])
self.stack.append((self.ret_addr, func_name, args))
try:
func = getattr(self, f'before_{func_name}')
if callable(func):
command = func(*args) or 'ok'
else:
command = 'ok'
if not callable(func):
func = None
except AttributeError:
command = 'ok'
func = None
try:
if func is None:
raise NotImplementedError()
command = func(*args) or self.before_fallback(func_name, *args) or 'ok'
except NotImplementedError:
command = self.before_fallback(func_name, *args) or 'ok'
print(f'[{self.pid}] -> {command}')
self.wfile.write(command.encode('utf-8') + b'\n')
else:
ret = data.decode('utf-8')
ret_value, _ = Handler.parse_arg(ret[7:])
func_name, args = self.stack.pop()
ret_value, _ = Handler.parse_arg(ret[7:].split(';')[0])
self.ret_addr, func_name, args = self.stack.pop()
try:
func = getattr(self, f'after_{func_name}')
if callable(func):
if ret_value is None:
func(*args)
else:
func(*args, ret_value)
if not callable(func):
func = None
except AttributeError:
pass
func = None
try:
if func is None:
raise NotImplementedError()
if ret_value is None:
func(*args)
else:
func(*args, ret_value)
except NotImplementedError:
if ret_value is None:
self.after_fallback(func_name, *args)
else:
self.after_fallback(func_name, *args, ret_value)
print(f'[{self.pid}] -> {ret}')
def before_malloc(self, size: int) -> str: pass
def before_malloc(self, size: int) -> str:
raise NotImplementedError()
def after_malloc(self, size: int,
ret_value: int, errno: str = None) -> None: pass
def before_calloc(self, nmemb: int, size: int) -> str: pass
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_calloc(self, nmemb: int, size: int) -> str:
raise NotImplementedError()
def after_calloc(self, nmemb: int, size: int,
ret_value: int, errno: str = None) -> None: pass
def before_realloc(self, ptr: int, size: int) -> str: pass
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_realloc(self, ptr: int, size: int) -> str:
raise NotImplementedError()
def after_realloc(self, ptr: int, size: int,
ret_value: int, errno: str = None) -> None: pass
def before_reallocarray(self, ptr: int, nmemb: int, size: int) -> str: pass
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_reallocarray(self, ptr: int, nmemb: int, size: int) -> str:
raise NotImplementedError()
def after_reallocarray(self, ptr: int, nmemb: int, size: int,
ret_value: int, errno: str = None) -> None: pass
def before_free(self, ptr: int) -> str: pass
def after_free(self, ptr: int) -> None: pass
def before_getopt(self, argc: int, argv: Pointer[list[Pointer[bytes]]], optstring: Pointer[bytes]) -> str: pass
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_free(self, ptr: int) -> str:
raise NotImplementedError()
def after_free(self, ptr: int) -> None:
raise NotImplementedError()
def before_getopt(self, argc: int, argv: Pointer[list[Pointer[bytes]]], optstring: Pointer[bytes]) -> str:
raise NotImplementedError()
def after_getopt(self, argc: int, argv: Pointer[list[Pointer[bytes]]], optstring: Pointer[bytes],
ret_value: int) -> None: pass
def before_close(self, fildes: int) -> str: pass
ret_value: int) -> None:
raise NotImplementedError()
def before_close(self, fildes: int) -> str:
raise NotImplementedError()
def after_close(self, fildes: int,
ret_value: int, errno: str = None) -> None: pass
def before_sem_init(self, sem: int, pshared: int, value: int) -> str: pass
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_sem_init(self, sem: int, pshared: int, value: int) -> str:
raise NotImplementedError()
def after_sem_init(self, sem: int, pshared: int, value: int,
ret_value: int, errno: str = None) -> None: pass
def before_sem_open(self, name: str, oflag: Flags, mode: Optional[int], value: Optional[int]) -> str: pass
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_sem_open(self, name: str, oflag: Flags, mode: Optional[int], value: Optional[int]) -> str:
raise NotImplementedError()
def after_sem_open(self, name: str, oflag: Flags, mode: Optional[int], value: Optional[int],
ret_value: int, errno: str = None) -> None: pass
def before_sem_post(self, sem: int) -> str: pass
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_sem_post(self, sem: int) -> str:
raise NotImplementedError()
def after_sem_post(self, sem: int,
ret_value: int, errno: str = None) -> None: pass
def before_sem_wait(self, sem: int) -> str: pass
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_sem_wait(self, sem: int) -> str:
raise NotImplementedError()
def after_sem_wait(self, sem: int,
ret_value: int, errno: str = None) -> None: pass
def before_sem_timedwait(self, sem: int, abs_timeout: Pointer[StructTimeSpec]): pass
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_sem_trywait(self, sem: int) -> str:
raise NotImplementedError()
def after_sem_trywait(self, sem: int,
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_sem_timedwait(self, sem: int, abs_timeout: Pointer[StructTimeSpec]) -> str:
raise NotImplementedError()
def after_sem_timedwait(self, sem: int, abs_timeout: Pointer[StructTimeSpec],
ret_value: int, errno: str = None): pass
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_sem_getvalue(self, sem: int, value_ptr: int) -> str:
raise NotImplementedError()
def after_sem_getvalue(self, sem:int, value_ptr: int,
ret_value: int, errno: str = None, value: int = None) -> None:
raise NotImplementedError()
def before_sem_close(self, sem: int) -> str:
raise NotImplementedError()
def after_sem_close(self, sem: int,
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_sem_unlink(self, name: Pointer[bytes]) -> str:
raise NotImplementedError()
def after_sem_unlink(self, name: Pointer[bytes],
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
def before_sem_destroy(self, sem: int) -> str:
raise NotImplementedError()
def after_sem_destroy(self, sem: int,
ret_value: int, errno: str = None) -> None:
raise NotImplementedError()
class MemoryAllocationTester(Handler):
@@ -284,6 +347,82 @@ class MemoryAllocationTester(Handler):
del self.allocated[ptr]
class ReturnValueCheckTester(Handler):
pass
class InterruptedCheckTester(Handler):
cycles: int = 50
counter: int = 0
last_func_name: Optional[str] = None
last_ret_addr: Optional[int] = None
tested_functions: dict[tuple[str, int], str]
@property
def while_testing(self) -> bool:
return self.counter % self.cycles != 0
def before(self) -> None:
self.tested_functions = {}
def after(self) -> None:
if self.while_testing:
self.error()
for (name, ret_addr), status in self.tested_functions.items():
print(f'{name} (0x{ret_addr:x}) -> {status}')
def error(self):
print(f'Error: Return value and errno EINTR not handled correctly in {self.last_func_name} (return address 0x{self.last_ret_addr:x})')
self.tested_functions[(self.last_func_name, self.last_ret_addr)] = 'failed'
self.counter = 0
self.last_func_name = None
self.last_ret_addr = None
def after_fallback(self, func_name: str, *args, **kwargs) -> None:
if self.while_testing and self.last_func_name != func_name:
self.error()
def before_sem_wait(self, sem: int) -> str:
if self.last_ret_addr and self.last_ret_addr != self.ret_addr:
self.error()
self.counter += 1
if self.while_testing:
self.last_ret_addr = self.ret_addr
self.last_func_name = 'sem_wait'
self.tested_functions[(self.last_func_name, self.last_ret_addr)] = 'running'
return 'fail EINTR'
else:
self.tested_functions[(self.last_func_name, self.last_ret_addr)] = 'passed'
self.last_ret_addr = None
self.last_func_name = None
return 'return 0'
def before_sem_trywait(self, sem: int) -> str:
self.counter += 1
if self.while_testing:
self.last_ret_addr = self.ret_addr
self.last_func_name = 'sem_trywait'
return 'fail EINTR'
else:
self.last_ret_addr = None
self.last_func_name = None
return 'return 0'
def before_sem_timedwait(self, sem: int, abs_timeout: Pointer[StructTimeSpec]) -> str:
self.counter += 1
if self.while_testing:
self.last_ret_addr = self.ret_addr
self.last_func_name = 'sem_timedwait'
return 'fail EINTR'
else:
self.last_ret_addr = None
self.last_func_name = None
return 'return 0'
def before_sem_post(self, sem: int) -> str:
return 'return 0'
def intercept(socket: str, handler: type[Handler]) -> None:
try:
with ThreadedUnixStreamServer(socket, handler) as server:

2
proj/server/src/server.py
View File

@@ -39,7 +39,7 @@ def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument('socket', metavar='FILE')
args = parser.parse_args()
intercept.intercept(args.socket, intercept.MemoryAllocationTester)
intercept.intercept(args.socket, intercept.InterruptedCheckTester)
if __name__ == '__main__':

36
proj/test1/src/intercept.c
View File

@@ -499,7 +499,7 @@ static void init(void) {
void *__sym(malloc)(size_t size) {
init();
msg("malloc(%li)", size);
msg("malloc(%li): %p", size, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -515,7 +515,7 @@ void *__sym(malloc)(size_t size) {
void *__sym(calloc)(size_t nmemb, size_t size) {
init();
msg("calloc(%li, %li)", nmemb, size);
msg("calloc(%li, %li): %p", nmemb, size, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -531,7 +531,7 @@ void *__sym(calloc)(size_t nmemb, size_t size) {
void *__sym(realloc)(void *ptr, size_t size) {
init();
msg("realloc(%p, %li)", ptr, size);
msg("realloc(%p, %li): %p", ptr, size, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -547,7 +547,7 @@ void *__sym(realloc)(void *ptr, size_t size) {
void *__sym(reallocarray)(void *ptr, size_t nmemb, size_t size) {
init();
msg("reallocarray(%p, %li)", ptr, size);
msg("reallocarray(%p, %li): %p", ptr, size, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -563,7 +563,7 @@ void *__sym(reallocarray)(void *ptr, size_t nmemb, size_t size) {
void __sym(free)(void *ptr) {
init();
msg("free(%p)", ptr);
msg("free(%p): %p", ptr, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -577,7 +577,7 @@ void __sym(free)(void *ptr) {
int __sym(getopt)(const int argc, char *const argv[], const char *shortopts) {
init();
msg("getopt(%i, %as, %es)", argc, argv, argc, shortopts);
msg("getopt(%i, %as, %es): %p", argc, argv, argc, shortopts, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -595,7 +595,7 @@ int __sym(getopt)(const int argc, char *const argv[], const char *shortopts) {
int __sym(close)(int fildes) {
init();
msg("close(%i)", fildes);
msg("close(%i): %p", fildes, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -611,7 +611,7 @@ int __sym(close)(int fildes) {
int __sym(sem_init)(sem_t *sem, int pshared, unsigned int value) {
init();
msg("sem_init(%p, %i, %u)", sem, pshared, value);
msg("sem_init(%p, %i, %u): %p", sem, pshared, value, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -640,9 +640,9 @@ sem_t *__sym(sem_open)(const char *name, int oflag, ...) {
mode_arg = va_arg(args, mode_t);
value = va_arg(args, unsigned int);
va_end(args);
msg("sem_open(%es, 0%o:|%s, 0%03o, %u)", name, oflag, ostr, mode_arg, value);
msg("sem_open(%es, 0%o:|%s, 0%03o, %u): %p", name, oflag, ostr, mode_arg, value, __builtin_return_address(0));
} else {
msg("sem_open(%es, 0%o:|%s)", name, oflag, ostr);
msg("sem_open(%es, 0%o:|%s): %p", name, oflag, ostr, __builtin_return_address(0));
}
char overwrite[BUFFER_SIZE];
@@ -714,7 +714,7 @@ sem_t *__sym(sem_open)(const char *name, int oflag, ...) {
int __sym(sem_post)(sem_t *sem) {
init();
msg("sem_post(%p)", sem);
msg("sem_post(%p): %p", sem, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -730,7 +730,7 @@ int __sym(sem_post)(sem_t *sem) {
int __sym(sem_wait)(sem_t *sem) {
init();
msg("sem_wait(%p)", sem);
msg("sem_wait(%p): %p", sem, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -746,7 +746,7 @@ int __sym(sem_wait)(sem_t *sem) {
int __sym(sem_trywait)(sem_t *sem) {
init();
msg("sem_trywait(%p)", sem);
msg("sem_trywait(%p): %p", sem, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -762,7 +762,7 @@ int __sym(sem_trywait)(sem_t *sem) {
int __sym(sem_timedwait)(sem_t *restrict sem, const struct timespec *restrict abs_timeout) {
init();
msg("sem_timedwait(%p, %p:{tv_sec: %li, tv_nsec: %li})", sem, abs_timeout, abs_timeout->tv_sec, abs_timeout->tv_nsec);
msg("sem_timedwait(%p, %p:{tv_sec: %li, tv_nsec: %li}): %p", sem, abs_timeout, abs_timeout->tv_sec, abs_timeout->tv_nsec, __builtin_return_address(0));
struct timespec overwrite;
if (mode >= 4) {
char buf[BUFFER_SIZE];
@@ -807,7 +807,7 @@ int __sym(sem_timedwait)(sem_t *restrict sem, const struct timespec *restrict ab
int __sym(sem_getvalue)(sem_t *restrict sem, int *restrict value) {
init();
msg("sem_getvalue(%p, %p)", sem, value);
msg("sem_getvalue(%p, %p): %p", sem, value, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -823,7 +823,7 @@ int __sym(sem_getvalue)(sem_t *restrict sem, int *restrict value) {
int __sym(sem_close)(sem_t *sem) {
init();
msg("sem_close(%p)", sem);
msg("sem_close(%p): %p", sem, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));
@@ -839,7 +839,7 @@ int __sym(sem_close)(sem_t *sem) {
int __sym(sem_unlink)(const char *name) {
init();
msg("sem_unlink(%es)", name);
msg("sem_unlink(%es): %p", name, __builtin_return_address(0));
char overwrite[BUFFER_SIZE];
if (mode >= 4) {
char buf[BUFFER_SIZE];
@@ -870,7 +870,7 @@ int __sym(sem_unlink)(const char *name) {
int __sym(sem_destroy)(sem_t *sem) {
init();
msg("sem_destroy(%p)", sem);
msg("sem_destroy(%p): %p", sem, __builtin_return_address(0));
if (mode >= 4) {
char buf[BUFFER_SIZE];
rcv(buf, sizeof(buf));

25
proj/test1/src/main.c
View File

@@ -5,6 +5,7 @@
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <semaphore.h>
static void usage(const char *prog_name) {
fprintf(stderr, "usage: %s [-a]\n", prog_name);
@@ -22,6 +23,29 @@ void do_something(void) {
free(mem);
}
void do_sem(void) {
sem_t sem;
sem_init(&sem, 0, 1);
sem_post(&sem);
while (sem_wait(&sem) == -1) {
if (errno != EINTR) {
// TODO fail
}
}
do_something();
sem_wait(&sem);
do_something();
sem_destroy(&sem);
}
int main(const int argc, char *const argv[]) {
for (int ch; (ch = getopt(argc, argv, "a")) != -1;) {
switch (ch) {
@@ -37,4 +61,5 @@ int main(const int argc, char *const argv[]) {
do_something();
do_something();
do_something();
do_sem();
}