Voraussetzungen

Um die Kernel-Warteschlangen im Userspace zu nutzen, muss der Administrator im Kernelquellcode die Optionen »NETFILTER_NETLINK_QUEUE« und »NETFILTER_XT_TARGET_NFQUEUE« aktivieren. Alle relevanten Punkte sammelt das Kernel-Konfigurationstool (»make menuconfig«) unter »Networking support | Networking Options | Network packet filtering framework (Netfilter) | Core Netfilter Configuration« (Abbildung 1). Einige Distributionen liefern ihre Standardkernel bereits mit NFQueue-Support aus, so etwa Open Suse.

Im neuen Kernel lädt der Administrator die Module »x_tables«, »xt_NFQUEUE« und »nfnetlink_queue«. Letzteres benötigt noch »nfnetlink«, »modprobe« lädt es automatisch mit. Voraussetzung für alle drei ist das Modul »ip_tables«, das »modprobe« als IPtables-Basismodul normalerweise automatisch mit dem ersten davon abhängigen Modul aktiviert. Kernel mit einer Versionsnummer vor 2.6.16 nutzen noch nicht das Xtable-Framework für die Netfilter-Implementierung, weshalb das »xt_NFQUEUE«-Modul dort »ipt_NFQUEUE« oder bei noch älteren Kerneln »ip_queue« heißt.

Abbildung 1: Optionen in der Kernelkonfiguration (»make menuconfig«) unter dem Punkt »Core Netfilter Configuration« aktivieren NFQueue im Kernel.

Programmierung

Um nun aus dem Userspace die NFQueue-Funktionen des Netfilter-Subsystems nutzen zu können, binden Programme die beiden Bibliotheken »libnetfilter_queue.so« und »libnfnetlink.so« ein. Debian- und Ubuntu-Anwender holen diese Bibliotheken und die zugehörigen Headerdateien in ihr System, indem sie die Pakete »libnetfilter-queue-dev« und »libnfnetlink-dev« installieren: Über das Kommando

aptitude install libnetfilter-queue-dev libnfnetlink-dev 

zieht Aptitude auf Debian-Systemen automatisch alle Abhängigkeiten nach, darunter auch die zuvor genannten Bibliotheken. Auch für Open Suse 11.1 gibt es bereits fertige Pakete im Netz [5] - die Dateien »libnfnetlink-devel-0.0.41-jen0.i586.rpm«, »libnfnetlink0-0.0.41-jen0.i586.rpm«, »libnetfilter_queue1-0.0.17 -jen0.i586.rpm« sowie »libnetfilter_queue -devel-0.0.17-jen0.i586.rpm« aus dem FTP-Verzeichnis installiert der Administrator mit »rpm«.

Während Debian für die veraltete Queue-Schnittstelle im Paket »iptables-dev« Manpages anbietet, die die Schnittstellen beschreiben (»man -k ipq« führt alle relevanten Seiten auf), gibt es für die NFQueue-Bibliotheksfunktionen keine entsprechende Dokumentation. Programmierer sind somit darauf angewiesen, die Headerdateien zu durchsuchen oder Beiträge von hilfsbereiten Entwicklern zu lesen, die ihre Erkenntnisse aus dem Umgang mit NFQueue dokumentiert haben. Erste Ansätze einer Beschreibung liefert etwa ein älterer Mailinglisten-Beitrag [6].

Tabelle 1: NFQueue-Funktionen

Nach der Konfiguration des Kernels und der Installation der Userspace-Pakete ist das System für die Arbeit mit den Warteschlangen bereit. Den grundlegenden Ablauf zeigt Abbildung 2: Vom Userspace aus greift ein Prozess auf die Bibliotheken zu, die als Schnittstelle zum Netfilter-Code im Kernel dienen. Dieser ist auch dafür zuständig, bestimmte Pakete in die Warteschlange einzureihen. Von dieser Warteschlange holt die »libnetfilter_queue«-Bibliothek die Pakete ab und reicht sie an das Programm im Userspace weiter.

Um auf die gewünschte Warteschlange und die darin befindlichen Netzwerkpakete zuzugreifen, arbeitet eine Anwendung, etwa die in Listing 1, nur wenige Schritte ab. Tabelle 1 beschreibt die verwendeten Funktionen aus der NFQueue-Bibliothek, Tabelle 2 erklärt die verwendeten Variablen.

Abbildung 2: Über die Bibliotheken »libnetfilter_queue« und »libnfnetlink« sowie die NFQueue-Module von Netfilter greifen Userspace-Anwendungen auf die im Kernel verwalteten Warteschlangen zu.

01 #include <fcntl.h>
02 #include <stdio.h>
03 #include <unistd.h>
04 
05 #include <arpa/inet.h>
06 #include <libnetfilter_queue/libnetfilter_queue.h>
07 #include <linux/icmp.h>
08 #include <linux/ip.h>
09 #include <linux/netfilter.h>
10 #include <sys/stat.h>
11 #include <sys/types.h>
12 
13 #define BUFSIZE 1024
14 
15 static int
16 callback_funktion(struct nfq_q_handle *queuehandle,
17        struct nfgenmsg *nfgmsg,
18        struct nfq_data *nfqd,
19        void *data)
20 {
21   int id, plen, useable, num, ret = 0;
22   char *pkt, *icmp_data;
23   struct nfqnl_msg_packet_hdr *h;
24   struct iphdr *iph;
25   struct icmphdr *icmph;
26 
27   h = nfq_get_msg_packet_hdr(nfqd);
28   if (h) {
29     id = ntohl(h->packet_id);
30     plen = nfq_get_payload(nfqd, &pkt);
31     printf("Processing packet %d ... ", id);
32 
33     iph = (struct iphdr *)pkt;
34     icmph = (struct icmphdr *)(pkt + sizeof(struct iphdr));
35     icmp_data = (char *)(pkt + sizeof(struct iphdr) + sizeof(struct icmphdr));
36     if (icmph->type != 8 && icmph->code != 0)
37       ret = nfq_set_verdict(queuehandle, id, NF_ACCEPT, 0, NULL);
38 
39     useable = plen - sizeof(struct iphdr) - sizeof(struct icmphdr);
40     num = read((int)data, icmp_data, useable);
41     printf("embedded %d bytesn", num);
42     ret = nfq_set_verdict(queuehandle, id, NF_ACCEPT, plen, (void *)pkt);
43   }
44 
45   return ret;
46 }
47 
48 int
49 main(int argc, char **argv)
50 {
51   int fd, nfqfd, num;
52   char buf[BUFSIZE];
53   struct nfq_handle *nfqh;
54   struct nfq_q_handle *queuehandle;
55 
56   if (argc != 2) {
57     fprintf(stderr, "Usage: %s FILENAMEn", argv[0]);
58     return 1;
59   }
60 
61   if ((fd = open(argv[1], O_RDONLY)) < 0) {
62     fprintf(stderr, "*** open()n");
63     return 1;
64   }
65 
66   nfqh = nfq_open();
67   if (!nfqh) {
68     fprintf(stderr, "*** nfq_open()n");
69     return 1;
70   }
71 
72   nfq_unbind_pf(nfqh, AF_INET);
73   if (nfq_bind_pf(nfqh, AF_INET) < 0) {
74     fprintf(stderr, "*** nfq_unbind_pf()n");
75     return 1;
76   }
77 
78   queuehandle = nfq_create_queue(nfqh, 0, callback_funktion, (void *)fd);
79   if (!queuehandle) {
80     fprintf(stderr, "*** nfq_create_queue()n");
81     return 1;
82   }
83 
84   if (nfq_set_mode(queuehandle, NFQNL_COPY_PACKET, BUFSIZE) < 0) {
85     fprintf(stderr, "*** nfq_set_mode()n");
86     return 1;
87   }
88 
89   nfqfd = nfq_fd(nfqh);
90   while((num = recv(nfqfd, buf, BUFSIZE, 0)) >= 0) {
91     nfq_handle_packet(nfqh, buf, num);
92   }
93 
94   nfq_destroy_queue(queuehandle);
95   nfq_close(nfqh);
96   close(fd);
97   return 0;
98 }