hallo liebes Forum,
ich hoffe Ihr könnt mir helfen.
und zwar "biege" ich einen Systemcall um (Execve). Ich möchte, dass meine eigene execve Systemcall (es passiert nichts) und der originalle execve abwechselnd aufgerufen werden.
Klingt erstmal kompliziert, die Grundidee die da hinter steckt ist folgende. Wenn ein Prozess gestartet wird (durch execve), soll das durch mein Kernelmodul verhindert werden. Beim zweiten Aufruf soll es aber wieder klappen.
So, an sich klappt das umbiegen. D.h. also dass wenn Prozess gestartet werden soll, dann wird das verhindert (mein execve wird aufgerufen. Beim zweiten mal wird dann wieder origninal execve aufgerufen. Das klappt! Nur nach dem originallen Aufruf, kommt man nicht zurück in das Modul. Ab da an, läuft execve wieder "normal".
Hier erstmal der Code (teil):
Im init_module() wird also die Adresse der originalen execve gesichter und dann der Syscalltable die unserer Funktion zugeordnet. In unserer Funktion our_sys_execve() wird dann beim zweiten mal der originale execve wieder aufgerunfe. DAnn ist aber Schluss
Ich hoffe jemand hier zu finden, der mir einen guten Tipp geben könnte.
Vielen, vielen Dank schonmal im Voraus)
ich hoffe Ihr könnt mir helfen.
und zwar "biege" ich einen Systemcall um (Execve). Ich möchte, dass meine eigene execve Systemcall (es passiert nichts) und der originalle execve abwechselnd aufgerufen werden.
Klingt erstmal kompliziert, die Grundidee die da hinter steckt ist folgende. Wenn ein Prozess gestartet wird (durch execve), soll das durch mein Kernelmodul verhindert werden. Beim zweiten Aufruf soll es aber wieder klappen.
So, an sich klappt das umbiegen. D.h. also dass wenn Prozess gestartet werden soll, dann wird das verhindert (mein execve wird aufgerufen. Beim zweiten mal wird dann wieder origninal execve aufgerufen. Das klappt! Nur nach dem originallen Aufruf, kommt man nicht zurück in das Modul. Ab da an, läuft execve wieder "normal".
Hier erstmal der Code (teil):
Code:
asmlinkage int our_sys_execve(const char *ufilename,
const char *const *uargv,
const char *const *uenvp,
struct pt_regs *regs)
{
printk("A file was executed %s, count=%d\n", ufilename,count);
count++;
if (count%2==0){
printk("Original execve, count = %d fn=%s\n",count,ufilename);
disable_page_protection();
sys_call_table[__NR_execve] = original_call_execve;
enable_page_protection();
original_call_execve(ufilename, uargv, uenvp, regs);
printk("Hier kommen wir leider nicht hin :-(\n");
}
disable_page_protection();
sys_call_table[__NR_execve] = our_sys_execve;
enable_page_protection();
return original_call_execve(ufilename, uargv, uenvp, regs);
}
int init_module()
{
// sys_call_table address in System.map
sys_call_table = (void*)0xffffffff8154e380;
//original_call = sys_call_table[__NR_open]; __NR_execve
original_call_execve = sys_call_table[__NR_execve];
printk("Orginal table %p\n", sys_call_table[__NR_execve]);
//set_page_rw(sys_call_table);
disable_page_protection();
//sys_call_table[__NR_open] = our_sys_open;
sys_call_table[__NR_execve] = our_sys_execve;
//set_page_ro(sys_call_table);
enable_page_protection();
printk("Function pointer: %p\n", our_sys_execve);
printk("Changed: table %p\n", sys_call_table[__NR_execve]);
printk("System initalized!\n");
return 0;
}Im init_module() wird also die Adresse der originalen execve gesichter und dann der Syscalltable die unserer Funktion zugeordnet. In unserer Funktion our_sys_execve() wird dann beim zweiten mal der originale execve wieder aufgerunfe. DAnn ist aber Schluss
Ich hoffe jemand hier zu finden, der mir einen guten Tipp geben könnte.
Vielen, vielen Dank schonmal im Voraus
)