[Linux - C] Intercettare chiamate di sistema

[WarDuck]

Ok, come da titolo, a scopo didattico vorrei intercettare le chiamate di sistema (ad esempio sys_open che consente l'apertura di un file).

L'idea è quella di usare un Linux Kernel Module e sostituire la voce corrispondente della sys_call_table con la mia nuova funzione.

Tuttavia facendo così il modulo mi crasha, presumo che ci sia una qualche protezione che impedisce la modifica della sys_call_table.

Ho cercato a lungo su Google, ma tutti gli esempi conducono a questo risultato.

Per altro a quanto ho letto dal kernel 2.6 in poi non è più esportata la sys_call_table, quindi ho dovuto leggere il valore della locazione di memoria dal file System.map.

Questo è il codice:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/syscalls.h>

unsigned long* sys_call_table = (unsigned long*)0xc0592150;

asmlinkage long (*def_sys_open)(const char *filename, int flags, int mode);

asmlinkage long mod_sys_open(const char *filename, int flags, int mode)
{
	printk(KERN_INFO "[HELLO MODULE] Intercepted system call! Filename: %s\n", filename);
	return def_sys_open(filename, flags, mode);
}

static int __init hello(void)
{

	printk(KERN_INFO "[HELLO MODULE] Init, sys_call_table open @ %lx\n", sys_call_table[__NR_open]);

	def_sys_open = (void*)sys_call_table[__NR_open];

	printk(KERN_INFO "[HELLO MODULE] default_sys_open @ %lx\n", (unsigned long)def_sys_open);

	printk(KERN_INFO "[HELLO MODULE] mod_sys_open @ %lx\n", (unsigned long)mod_sys_open);

	sys_call_table[__NR_open] = (unsigned long)mod_sys_open;

	//	default_sys_open =(void * )xchg(&sys_call_table[__NR_open], mod_sys_open);

	return 0;
}

static void __exit bye(void)
{
	sys_call_table[__NR_open] = (unsigned long)def_sys_open;
	printk(KERN_INFO "[HELLO MODULE] Goodbye world.\n");
}

module_init(hello);
module_exit(bye);

Lo scopo è quello di individuare le chiamate alla open ed eventualmente gestirla in maniera opportuna, se conoscete altri modi (forse più consoni) fatemi sapere .

Edit: fantastico ho appena scoperto che la sys_call_table è diventata read-only... trovato su un forum nascosto nei meandri della rete... :-( a questo punto?

[tomminno]

Usare LD_PRELOAD?

[Unrue]

Probabilmente il comando strace fa al caso tuo:

strace <tuoprogramma>

[DanieleC88]

Personalmente non me ne intendo così tanto, ma so che nella mia università è stato portato avanti un progetto che usa una tecnica simile. I sorgenti li si può leggere, quindi ti linko:

• la pagina del progetto: http://twiki.dsi.uniroma1.it/twiki/view/Remus
• la pagina di sourceforge.net: http://sourceforge.net/projects/remus/

ciao

EDIT: la parte "interessante" è /module/remus_intercept.c.

[DanieleC88]

Originariamente inviato da WarDuck

Edit: fantastico ho appena scoperto che la sys_call_table è diventata read-only... trovato su un forum nascosto nei meandri della rete... :-( a questo punto?

Ehm sì, da una ricerca più approfondita giungo al tuo stesso risultato...
Anzi: questo tipo risolve il problema patchando il kernel... http://kerneltrap.org/node/16668

L'alternativa sarebbe una libreria+LD_PRELOAD, ma non funzionerebbe sui programmi compilati staticamente.

[WarDuck]

Innanzitutto grazie per le risposte, gli ho dato uno sguardo veloce:

@tommino: appena ho tempo provo, ma se come ho letto è una environment variabile credo che sarebbe abbastanza facile eludere l'hook.

Quello che vorrei fare è limitare di default l'azione degli eseguibili sul file system, possibilmente rendendo difficile la vita a chi vorrebbe agirare il sistema .

@unrue: strace dovrebbe servire a vedere quali chiamate di sistema usa un dato eseguibile, un comando molto utile ma purtroppo non aiuta a risolvere il problema (che in questo caso è intercettare le chiamate e "modificare" il loro comportamento).

@daniele: anche qui da quanto vedo si basa tutto sul kernel 2.4, purtroppo dal kernel 2.6 (in particolare le ultime versioni) molti trucchi non funzionano più.

Ho comunque continuato a cercare e ho letto che sarebbe possibile modificare la page table in maniera tale da rendere scrivibile l'area di memoria della sys_call_table (che di default è read-only).

In questo caso si potrebbe rendere l'area rw, modificare la tabella e rimetterla read-only.

Ci sono cmq modi di agire a più basso livello (tipo intercettare direttamente l'interrupt e modificare i registri relativi), ma prima dovrei studiarmi l'assembly intel .

Grazie a tutti per le risposte, appena ho un po' di tempo rileggo tutto con calma.

[eraser]

Non mi intendo in profondità di Linux, ma in Windows la modifica del System Service Descriptor Table (conosciuto anche come KiServiceTable) - che è esattamente quello che vuoi fare tu su linux - richiede la disabilitazione del flag Write Protect al fine di poter scrivere in zone di memoria del kernel marcate come read only.

Il flag Write Protect è il bit 16 del registro CR0 (uno dei Control Register) nella CPU x86.

The CR0 register is 32 bits long on the 386 and higher processors. On x86-64 processors in long mode, it (and the other control registers) are 64 bits long. CR0 has various control flags that modify the basic operation of the processor.

Bit 16
Name WP
Full Name Write protect
Description Determines whether the CPU can write to pages marked read-only

Un codice simile è spesso utilizzato per modificare la KiServiceTable in Windows:

cli
mov eax,cr0
and eax,0xFFFEFFFF
mov cr0,eax
sti

per riabilitare il WP flag poi il codice è il seguente:

cli
mov eax,cr0
or eax,10000h
mov cr0,eax
sti

Ma non so se sia possibile applicarlo anche a Linux, concettualmente penso di si ma ciò va fuori dal mio campo di conoscenze

[eraser]

Ovviamente, ma questo era scontato, il codice sopra evidenziato deve essere eseguito con privilegi equivalenti o maggiori del codice necessario per interagire con il kernel e i registri della CPU.
(Nel caso in questione, in Windows, il codice deve essere eseguito almeno in ring 0)

[marco.r]

Quello che vorrei fare è limitare di default l'azione degli eseguibili sul file system, possibilmente rendendo difficile la vita a chi vorrebbe agirare il sistema .

C'e' qualche motivo per cui non puoi usare i regolari permessi di sistema o al piu' qualche funzionalita' un po' piu' avanzata come AppArmor/selinux etc ?