security at sixserv blog

Archive for the ‘security’ tag

kernel mode sockets part 2 (the clean way)

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

Geschrieben von nks

30. August 2008 @ 02:34

Posted in coding, linux

Tagged with coding, kernel, linux, networking, security

kernel mode sockets part 1 (the dirty way)

mit einem Kommentar

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…

Geschrieben von nks

29. August 2008 @ 01:38

Posted in coding, linux

Tagged with coding, kernel, linux, networking, security

sixserv blog

Archive for the ‘security’ tag

kernel mode sockets part 2 (the clean way)

kernel mode sockets part 1 (the dirty way)

Seiten

Kategorien

Blogroll

Podcasts

Archiv

Tags

Letzte Artikel

Letzte Kommentare

apoc@Twitter

nks@Twitter

Meta

Januar 2009
M	D	M	D	F	S	S
« Dez
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31