sixserv blog

version 0.1 -  30.08.2008

willkommen zu teil 2 der linux kernel mode socket serie. nun befassen wir uns mit einem sauberem weg der socketcalls vom kernel aus. auch hierfuer gibt es noch andere wege. in einem der naechstem teile bauen wir uns eine socket()-funktion selber, aber nun zum sauberem socket

auch hier muessen wir wieder set_fs/get_fs (man kann sie auch weglassen, aber in diesem fall garantiere ich fuer NICHTS, bzw das modul laesst sih kompilieren aber die funktion funktioniert im besten fall nicht…) nutzen da file-operationen im kernelmode nicht gestattet sind, der zugriff auf sockets ist ein dateizugriff. die funktion inet_addr muessen wir uns nicht extra schreiben, hab ich zwischenzeitlich rausgfeunden in der “linux/inet.h” gibt es in_aton()

die hauptschwierigkeit besteht in den neuen strukturen iovec und msghdr. die ich allerdings anhand von kommentaren erklaeren werde, soweit wichtig, bzw unter den beiden links steht alles was man wissen muss (obwohl es nich spezifisch um die linux strukturen geht).

kommen wir nun zum code:

/*
* lkm_clean_socket.c - nks
*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/socket.h>
#include <linux/net.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <net/sock.h>
#include <asm/uaccess.h>

int init_module(void)
{
struct socket *socket;
struct sockaddr_in saddr;
int errno;
char buffer[1024];
struct msghdr msg;
struct iovec iov;
mm_segment_t old_fs;

printk(KERN_INFO "#sixserv/sixserv.org presents:\n");
printk(KERN_INFO "simple & clean kernel mode socket - nks\n");

if ((errno = sock_create(PF_INET,SOCK_STREAM,IPPROTO_TCP,&socket))<0)
{
printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
printk(KERN_INFO "-- ERRNO: %d..\n",errno);
return 0;
}
else
{
printk(KERN_INFO "++ Kernel Mode Socket is up ...\n");
printk(KERN_INFO "++ ERRNO: %d..\n",errno);
}

saddr.sin_addr.s_addr = in_aton("79.140.33.153");
saddr.sin_port = htons(80);
saddr.sin_family = AF_INET;

if ((errno = socket->ops->connect(socket,(struct sockaddr*)&saddr,sizeof(saddr),0))<0)
{
printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
printk(KERN_INFO "-- ERRNO: %d..\n",errno);
return 0;
}
else
{
printk(KERN_INFO "++ Kernel Mode Socket is up an connected...\n");
printk(KERN_INFO "++ ERRNO: %d..\n",errno);
}

iov.iov_base = "GET / HTTP/1.0\r\n\r\n";
iov.iov_len = sizeof("GET / HTTP/1.0\r\n\r\n");

msg.msg_iov = &iov;
msg.msg_iovlen = 1;  /* anzahl der elemente in iov */
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_flags    = 0;

old_fs = get_fs();
set_fs(KERNEL_DS);

if ((errno = sock_sendmsg(socket,&msg,sizeof("GET / HTTP/1.0\r\n\r\n")))<0)
{
printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
printk(KERN_INFO "-- ERRNO: %d..\n",errno);
set_fs(old_fs);
return 0;
}
else
{
printk(KERN_INFO "++ Kernel Mode Socket is sending stuff...\n");
printk(KERN_INFO "++ ERRNO: %d..\n",errno);
set_fs(old_fs);
}

iov.iov_base = buffer;
iov.iov_len = 1024;

msg.msg_iov = &iov;
msg.msg_iovlen = 1;  /* anzahl der elemente in iov */
msg.msg_control = NULL;
msg.msg_name = NULL;
msg.msg_namelen = 0;

old_fs = get_fs();
set_fs(KERNEL_DS);

set_fs(old_fs);

if ((errno = sock_recvmsg(socket,&msg,1024,0))<0)
{
printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
printk(KERN_INFO "++ ERRNO: %d..\n",errno);
set_fs(old_fs);
return 0;
}
else
{
printk(KERN_INFO "++ Kernel Mode Socket is recieving stuff...\n");
printk(KERN_INFO "++ ERRNO: %d..\n",errno);
printk(KERN_INFO "++ Recieved: %s..\n",buffer);
set_fs(old_fs);

}
return 0;
}

void cleanup_module(void)
{
printk(KERN_INFO "Goodbye world.\n");
}

MODULE_LICENSE("GPL");

ein weiteres mal passen wir unsere Makfeile an:

obj-m += lkm_clean_socket.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

nach einem make ist das modul fertig und liegt unter dem namen “lkm_clean_socket.ko” im aktuellem verzeichnis.
wenn alles geklappt hat machen wir folgendes:

# modinfo lkm_clean_socket.ko
filename:       lkm_clean_socket.ko
license:        GPL
depends:
vermagic:       2.6.25-gentoo-r7 SMP mod_unload PENTIUM4
# insmod lkm_clean_socket.ko
# dmesg
....

++ Kernel Mode Socket is up ...
++ ERRNO: 0..
++ Kernel Mode Socket is up an connected...
++ ERRNO: 0..
++ Kernel Mode Socket is sending stuff...
++ ERRNO: 19..
++ Kernel Mode Socket is recieving stuff...
++ ERRNO: 1024..
++ Recieved: HTTP/1.1 200 OK
Date: Sat, 30 Aug 2008 00:18:58 GMT
Server: Apache
X-Powered-By: PHP/5.2.0-8+etch11
X-Pingback: http://sixserv.org/xmlrpc.php
Connection: close
Content-Type: text/html; charset=UTF-8

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" lang="de-DE">
<head profile="http://gmpg.org/xfn/11">
<title>sixserv blog</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<meta name="description" content="welcome to teh #sixserv!" />
<meta name="generator" content="WordPress 2.6.1" /> <!-- leave this for stats please -->
<link href="http://sixserv.org/wp-content/themes/journalist/style.css" rel="stylesheet" type="text/css" media="screen" />
<link rel="alternate" type="application/rss+xml" title="sixserv blog RSS Feed" href="http://sixserv.org/feed/" />
<link rel="shortcut icon" type="image/x-png" href="http://sixserv.org/wp-content/the
....
# rmmod lkm_clean_socket.ko

wie man sehen kann ist unser buffer ein wenig zu klein, und die errnos kann man sich eigtl auch sparen wenn kein fehler auftritt.

seid gespannt auf den naechsten teil der kernel mode serie

nks

quellen:

• http://mail.nl.linux.org/kernelnewbies/2001-10/msg00079.html
• http://docs.sun.com/app/docs/doc/819-2257/iovec-9s?a=view
• http://www.dre.vanderbilt.edu/Doxygen/Stable/ace/structmsghdr.html
• http://qos.ittc.ku.edu/netlink/html/node7.html
• linux-2.4.34.1/ net/ khttpd/*
• include/linux/net.h
• /usr/src/linux/*

ps:
cuil.com und metager2.de lassen sich beide in die suchleiste oben integrieren (klickt einfach auf den namen dann fragt euch FF). nach einigem testen gefaellt mir metager2 wesentlich besser weil es VIEL mehr findet. allerdings gefaellt mir die aufmachung von cuil.com, ich sehe noch einiges an potenzial.

pps:
mal wieder ein musikalischer tipp
http://www.myspace.com/blue_nine

ich nutze gerne den bittorrent-client “BitLet”. wirklich genial und einfach. zeigt sehr schoen wie man mit Java auch nicht resourcenfressende ressourcen-schonende torrent-clients schreiben kann, im gegensatz zu Azureus/Vuze. ich nutze BitLet recht haeufig jedoch bereitet mir schon seit laengerem sorgen, dass auf der startseite eine history der letzten torrents liegt. das ist natuerlich sehr prakitsch fuers resumen bzw um den aktuellen stand des downloads zu sehen und ihn bei bedarf zu loeschen oder zu resumen, allerdings liegen diese daten auf dem server von BitLet.org.
BitLet hat somit auf ihren servern eine datenbank laufen die die IPs logt mit denen die user ihre downloads taetigen und die entsprechenden namen der .torrent-Files (mit ausgelesenen meta-daten und download-fortschritt). das wird vermutlich ueber ein cookie realisiert.

also ab und zu mal cookies loeschen…

bleibt abzuwarten was sich daraus ergibt.

nks

links:

• http://bitlet.org
• http://vuze.com

version 0.2 - 29.08.2008

kernel mode sockets sind hoch-interessant. im ersten teil befasse ich mich mit einer einfachen implementierung einses ziemlich simplen kernel mode sockets, das ist nicht der weg wie man es machen sollte allerdings hilft es erstmal dem grundsaetzlichem verstaendnis von lkm - also kernel modulen unter linux.

es ist natuerlich trotzdem moeglich diesen code in einem rootkit zu verwenden etc. aber ich finde das dieser code nichts in einem produktiven umfeld zu suchen hat, man oeffnet keine dateien aus derm kernel mode.

wir beginnen mit den basics eines lkm.

wir beginnen mit dem klassischem “Hello world.”:

/*
*  lkm_hello_world.c
*/
#include <linux/module.h>
#include <linux/kernel.h>

int init_module(void)
{
printk(KERN_INFO "Hello world.\n");
}
void cleanup_module(void)
{
printk(KERN_INFO "Goodbye world.\n");

}

zum kompilieren des moduls legen wir nun ein Makefile an:

obj-m += lkm_hello_world.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

vielleicht hat der ein oder andere versucht die sys/socket.h (etc.) einzubinden, aber das geht nicht. man sollte das auch nicht machen da das user-mode includes sind. also machen wir weiter, wir erstellen wir einen simplen (dirty) socket im kernel mode. ich hab mich dazu entschieden das wir den socket ueber den syscall “socketcall()” erstellen. um syscalls aus dem kernel aufrufen zu koennen gab es bis kernel 2.6.19 die syscall macros (fuer alle mit einem neuerem kernel habe ich einen kleinen header mti den macros hochgeladen), allerdings kann man eigtl keine syscalls vom kernel aus machen, damit wir das koennen muessen wir aus derm kernel-space addressraum in den user space addressraum, das geschieht hier per set_fs(). und schon kann man userspace calls ausfuehren.

/*
*  lkm_dirty_socket.c - nks
*/
#include "syscall_macros.h" /* auskommentieren wenn die kernel version
unter 2.6.19/18 ist! */

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

#include <linux/socket.h>
#include <linux/net.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/netdevice.h>

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

#include <linux/fcntl.h>
#include <asm/uaccess.h>
#include <linux/unistd.h>

int errno; /* needed by socketcall() */

/*
int socketcall(int call, unsigned long *args);
wie wir sehen koennen werden der funktion socketcall() 2 call uebergeben,
also benutzen wir das _syscall2-makro:
*/
static inline _syscall2(int, socketcall, int, call, unsigned long *, args);
int init_module(void)
{
        unsigned long arg[3];
        int socket;
        mm_segment_t old_fs;
        struct sockaddr_in addr;
        struct sockaddr_in saddr;

        printk(KERN_INFO "#sixserv/sixserv.org presents:\n");
        printk(KERN_INFO "simple kernel mode socket - nks\n");

        old_fs = get_fs();

        /* die argumente fuer socketcall vorbereiten*/
        arg[0] = PF_INET;
        arg[1] = SOCK_STREAM;
        arg[2] = 0;

        set_fs(KERNEL_DS);
        if ((socket = socketcall(1, arg)) == -1) // SYS_SOCKET = 1
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "-- ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is up ...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
        }

        return 0;
}

void cleanup_module(void)
{
        printk(KERN_INFO "Goodbye world.\n");
}

nun muessen wir die Makefile an das neue modul anpassen

obj-m += lkm_dirty_socket.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

nun koennen wir mit einem

# make
#insmod lkm_dirty_socket

das modul bauen und laden, mit dmesg sollte man dann die meldungen sehen ob es geklappt hat sieht man wenn der folgende text in der debug ausgaber erscheint:

++ Kernel Mode Socket is up …

aber nur ein socket alleine ist ja bekanntlich ziemlich langweilig
also verbinden wir uns mit einem http server. hierfuer muessen wir noch ein paar anpassungen an unserem bestehendem code taetigen:

/*
*  lkm_dirty_socket.c - nks
*/
#include "syscall_macros.h" /* auskommentieren wenn die kernel version unter 2.6.19/18 ist! */

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

#include <linux/socket.h>
#include <linux/net.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/netdevice.h>

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

#include <linux/fcntl.h>
#include <asm/uaccess.h>
#include <linux/unistd.h>
int errno; /* needed by socketcall() */

/*
int socketcall(int call, unsigned long *args);
wie wir sehen koennen werden der funktion socketcall() 2 parameter uebergeben,
also benutzen wir das _syscall2-makro:
*/
static inline _syscall2(int, socketcall, int, call, unsigned long *, args);
int init_module(void)
{
        unsigned long arg[3];
        int socket;
        mm_segment_t old_fs;
        struct sockaddr_in addr;
        struct sockaddr_in saddr;
        unsigned long arg1[3];
        unsigned long args[4];
        char buffer[1024];

        printk(KERN_INFO "#sixserv/sixserv.org presents:\n");
        printk(KERN_INFO "simple kernel mode socket - nks\n");

        old_fs = get_fs();

        arg[0] = PF_INET;
        arg[1] = SOCK_STREAM;
        arg[2] = 0;

        set_fs(KERNEL_DS);
        if ((socket = socketcall(1, arg)) == -1) // SYS_SOCKET = 1
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "-- ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is up ...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
        }

        saddr.sin_addr.s_addr = inet_addr("79.140.33.153");
        saddr.sin_port = htons(80);
        saddr.sin_family = AF_INET;
        /* argumente fuer connect():
            int connect(int sockfd, struct sockaddr *serv_addr, int addrlen );
        */
        arg1[0] = socket;
        arg1[1] =  (unsigned long)&saddr;
        arg1[2] =  (unsigned long)sizeof(saddr);

         if ((socketcall(SYS_CONNECT, arg1)) == -1)
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "-- ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is up an connected...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
        }

        /* argumente fuer send():
            send(int s, const void *buf, size_t len, int flags);
        */
        args[0] = socket;
        args[1] = "GET / HTTP/1.0\r\n\r\n";
        args[2] = strlen("GET / HTTP/1.0\r\n\r\n");
        args[3] = 0;

         if ((socketcall(SYS_SEND, args)) == -1)
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "-- ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is sending stuff...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);

        }

        /* argumente fuer recv():
            int recv(int s, void *buf, size_t len, int flags);
        */
        args[0] = socket;
        args[1] = (unsigned long) buffer;
        args[2] = 1024;
        args[3] = 0;

        if ((socketcall(SYS_RECV, args)) == -1)
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is recieving stuff...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
                printk(KERN_INFO "++ Recieved: %s..\n",buffer);

        }

       set_fs(old_fs);
       return 0;
}

void cleanup_module(void)
{
        printk(KERN_INFO "Goodbye world.\n");
}

unsigned int inet_addr(char *str)
{
        int a,b,c,d;
        char arr[4];
        sscanf(str,"%d.%d.%d.%d",&a,&b,&c,&d);
        arr[0] = a; arr[1] = b; arr[2] = c; arr[3] = d;
        return *(unsigned int*)arr;
}

wie ist eine neue funktion hinzugekommen inet_addr, aber viel interessanter sind die neuen socketcalls, beim lesen kann man anhand des call-arguments gut sehen welche socket-funktion nun aufgerufen wird. zur uebergabe der parameter verwenden wir ein char array bzw zwei da recv und send jeweils 4 argumente haben.

die syscall macros hab ich fuer euch hochgeladen

quellen:

• http://www.linuxjournal.com/node/8110/print
• http://www.ibm.com/developerworks/linux/library/l-system-calls/
• http://www.ibm.com/developerworks/linux/library/l-lkm/
• http://www.gnugeneration.com/mirrors/kernel-api/book1.html
• http://www.tldp.org/LDP/lkmpg/2.6/html/
• http://www.ussg.iu.edu/hypermail/linux/kernel/0303.2/2007.html (inet_addr())
  
• http://google.com/codesearch/
• http://lkml.org
• http://kerneltrap.org
• /usr/src/linux/*
• syscall_macros.h

bei fragen etc. kommt doch einfach ins irc (#nullserv/#sixserv im freenode)

nks

ps:
benutzt oefters mal google alternativen.. http://cuil.com oder http://metager2.de

pps:
chillig, und wie ich finde sehr geil: http://www.myspace.com/17thboulevard
bin gespannt auf das album…

Vor ein paar Tagen entstand die Idee einen gemeinsamen Server zu mieten, ein Kommilitone hatte uns auf Goekal-IT gebracht, drei Tage später, überzeugt von dem guten Angebot, war der Server bereits gemietet und es konnte mit dem Installieren und Konfigurieren des Debian Stable-Systems begonnen werden. Es läuft noch längst nicht alles, was wir uns beim Brainstorming vorgenommen haben, aber ein guter Anfang ist schon mal diese Wordpress-Installation.

Später vielleicht mehr dazu, aber bis dahin erkläre ich dieses Weblog für Eröffnet!