Kernel Module Tutorials?

Habe jetzt folgenden Code gefunden und angepasst:

void *get_sys_call_table(void *system_call)
{
  	unsigned char *p;
  	unsigned long s_c_t;
  	int count = 0;
  	p = (unsigned char *) system_call;
  	while (!((*p == 0xff) && (*(p+1) == 0x14) && (*(p+2) == 0x85)))
  	{
      		p++;
      		if (count++ > 500)
      		{
          		count = -1;
          		break;
      		}
  	}
  	if (count != -1)
  	{
      		p += 3;
      		s_c_t = *((unsigned long *) p);
  	}
  	else
      		s_c_t = 0;

  	return((void *) s_c_t);
}

static void output (void)
{

        void* rt_w = get_system_call();
	unsigned long sys_call_table = (unsigned long)get_sys_call_table(rt_w);
	printk("%lu", sys_call_table);

}

Sollte ds so funktionieren?
Sind irgendwo Gedankenfehler dabei?

Lies dir das hier mal durch: http://www.dtors.org/papers/malicious-code-injection-via-dev-mem.pdf

Ist zwar nicht genau was du willst, aber dort wird beschrieben wie man die sys_call_table vom Userspace aus findet. Ich denke dein Code-Snippet macht im Grunde das gleiche.
Übrigens es hat sicher einen Grund, dass du nicht so einfach in die sys_call_table schreiben kannst (der Compilerfehler). Aber schau doch mal ein wenig im Kernel nach .?sys_call_table[.?]\w=\w**, also nach diesem regulären Ausdruck, dann solltest du einige Beispiele finden.

Danke

Aber ich wollte eigentlich eher ein Modul für den Kernel schreiben und nicht die /dev/mem bzw. /dev/kmem methode anwenden.

Beim obigen Code von mir scheint aber was nicht zu stimmen. Als sys adresse bekomme ich eine 12 stellige zahl?

curry-king

supertux schrieb:

dann könnten Cracker-Newbies das benutzen, um später Böses zu tun.

und deswegen schützen wir uns alle und zensieren das Zeug

kann mir noch wer weiterhelfen?

Die wenigstens haben halt Lust ihre Zeit zu investieren, wenn das Vorhaben für sie sinnlos ist und du hast halt einfach jetzt den Skriptkiddie-Touch bzw. ein entsprechendes Thema.
Hättest du dagegen gefragt wie man die syscall-Tabelle beschreibt, da du ein Modul programmieren möchtest das Aufruf-Statistiken der Syscalls erstellt, dann hätten sich sicher Leute gefunden die dir geholfen hätten. Musst halt wissen wie man fragt

Die Syscall table und den Interrupt Handler und dessen Zusammenhänge verstehe ich ja. Ich habe einen Code gefunden, welcher eigentlich die oben beschriebene /dev/mem Methode, ausnutzen sollte:

#include <stdio.h>
#include <fcntl.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/param.h>
#include <linux/kernel.h>
#include <linux/version.h>
#include <linux/unistd.h>
#include <linux/string.h>
#include <asm/errno.h>
#include <linux/errno.h>
#include <linux/stat.h>

/*
#define KERN_START 0xC0000000

int iskernaddr ( unsigned long addr ) 
{
	if (addr < KERN_START)
		return -1;

	return 0;
}

int readvirt (unsigned long addr, void* buf, unsigned int len)
{
	if (iskernaddr (addr) < 0)
		return -1;

	addr = addr - KERN_START;
	lseek (mem_fd, addr, SEEK_SET);

	return read(mem_fd, buf, len);
}
struct idtentry {
    uint16_t lo ;
    uint16_t css ;
    uint16_t flags ;
    uint16_t hi ;
}   attribute ( ( packed ) ) ;

int read_mem_linux()
{
	int mem_fd;
	int ret = 1;
	char var_char[4];
	char *charp;
	int count = 0;

	if((mem_fd = open("/dev/mem",O_RDONLY)) < 0)
	{
		printf("\n\nProblem in opening /dev/mem: are you root, lamorz?\n\n");
		return -1;
	}
	charp = (char *)malloc(sizeof(char) * 1024 * 1024);

	while(ret != 0 && ret != -1)
	{
		ret = read(mem_fd, charp,sizeof(char) * 1024 *1024);
		printf("\nret:%d",ret);
		if (ret > 0)
		count++;
	}
	printf("\nMemory Read:%d MB",count);
}

int main (int argc, char* argv[])
{
	read_mem_linux();
}*/

 #include <stdio.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <stdlib.h>

 int kfd;

 struct
 {
 	 unsigned short limit;
 	 unsigned int base;
 } __attribute__ ((packed)) idtr;

 struct
 {
 	 unsigned short off1;
 	 unsigned short sel;
 	 unsigned char none, flags;
  	 unsigned short off2;
 } __attribute__ ((packed)) idt;

 int readkmem (unsigned char *mem, 
              unsigned off, 
              int bytes)
 {
	  if (lseek64 (kfd, (unsigned long long) off, 
                                    SEEK_SET) != off)
	  {
       	 	 return -1;
	  }

 	 if (read (kfd, mem, bytes) != bytes) 
	 {
        	 return -1;
	 }

 }

 int main (void)
 {
 	 unsigned long sct_off;
 	 unsigned long sct;
  	 unsigned char *p, code[255];
 	 int i;

/* request IDT and fill struct */

	asm ("sidt %0":"=m" (idtr));

	if ((kfd = open ("/dev/kmem", O_RDONLY)) == -1)
	{
       	 	perror("open");
        	exit(-1);
	}

	if (readkmem ((unsigned char *)&idt, idtr.base + 8 * 0x80, sizeof (idt)) == -1)
	{
        	printf("Failed to read from /dev/kmem\n");
        	exit(-1);
	}

	sct_off = (idt.off2 << 16) | idt.off1;

	if (readkmem (code, sct_off, 0x100) == -1)
	{
        	printf("Failed to read from /dev/kmem\n");
        	exit(-1);
	}

/* find the code sequence that calls SCT */

 sct = 0;
	for (i = 0; i < 255; i++)
	{
        	if (code[i] == 0xff && code[i+1] == 0x14 && 
                                        code[i+2] == 0x85)
                	sct = code[i+3] + (code[i+4] << 8) + 
                        (code[i+5] << 16) + (code[i+6] << 24);
	}
	if (sct)
 	   	printf ("sys_call_table: 0x%x\n", sct);
	close (kfd);
 }

Wobei ich das als root ausführe und die Meldung bekomme:

open: No such device or address

Auch das bringt mir folgendes Ergebnis:

sudo cat /dev/kmem
cat: /dev/kmem: No such device or address

Diese Möglichkeit nicht mehr aktuell?
Oder sonstige Denkfehler?

Vielen Dank schonmals für Anregungen

Versuchs mal bei Gulli...

supertux

@Mod: kann man das hier bitte dicht machen?

___mario schrieb:

Versuchs mal bei Gulli...

ja natürlich, bei gulli...
ansammlung von script kiddies und kindern?

@Mod: kann man das hier bitte dicht machen?

Nur weil es deiner Meinung nach nicht legal ist?
Natürlich, wir tun alles was der große tux will!

supertux

kernelp schrieb:

Nur weil es deiner Meinung nach nicht legal ist?

es ist nicht meine Meinung sondern mittlerweile ein Gesetzt.