sixserv blog » Linux http://sixserv.org A Blog about Linux, Networking, Development and Security. Tue, 27 Jul 2010 16:45:57 +0000 en hourly 1 http://wordpress.org/?v=3.0 Memory Debugging or a “Universal Game Trainer” with Python and ptrace http://sixserv.org/2010/07/26/memory-debugging-or-a-universal-game-trainer-with-python-and-ptrace/ http://sixserv.org/2010/07/26/memory-debugging-or-a-universal-game-trainer-with-python-and-ptrace/#comments Mon, 26 Jul 2010 13:35:22 +0000 apoc http://sixserv.org/?p=656
Reading and writing other process memory can have many different purposes: besides debugging, this technique is probably most frequently known to be used by game trainers, to alter different values of a running game (like the value of health or money). Most (if not all) of the game trainers available, are developed for Windows and [...]]]>

Reading and writing other process memory can have many different purposes: besides debugging, this technique is probably most frequently known to be used by game trainers, to alter different values of a running game (like the value of health or money).

Most (if not all) of the game trainers available, are developed for Windows and only for a specific game, but there are some universal trainers, that could be used to locate and change values in memory of any game or application and with kcheat and Tursiops there are some solutions for Linux.
I’ve developed a proof of concept to locate and change any byte value using python and the ptrace bindings. ptrace is a Unix system call for controlling other processes, it is for instance used by the gdb debugger.

The following code creates a debugging instance and attaches the other process by PID:

from ptrace.debugger.debugger import PtraceDebugger
 
dbg = PtraceDebugger()
process = dbg.addProcess(1234, False)

Now the process instance can be used to inspect and manipulate the process. To manipulate the memory it is important to know the virtual memory mappings (‘areas’) of the process:

from ptrace.debugger.memory_mapping import readProcessMappings
 
memory_mapping = readProcessMappings(process)

Now the list contains MemoryMapping instances, describing the virtual memory areas of the process. We are interested in their location and permission (Quickref: mapping.start, mapping.end, mapping.permissions). The trainer should only be searching within memory mappings with “rw” permissions.

Last but not least, the reading and writing from/to memory methods:

value = process.readBytes(0x11223344, 1) # this reads 1 byte
process.writeBytes(0x11223344, value) # writes len(value) bytes

After that you can close the debugger instance by:

dbg.quit()

I encountered some difficulties with closing/detaching the debugging process, it seems that the process is only really detached if the script is terminated, as a workaround I forked the memory search process, to circumvent that in my proof of concept trainer.

That’s it! If you’re interested, you can checkout my proof of concept for a universal game trainer: pycheat.py (GPLv3) It can locate and change byte values (char) in other processes memory:

% python pycheat.py 8169
pycheat: universal game trainer v0.1
process id: 8169
highest address: 0xffffff
 
searching for address by byte value: 23
search memory area[0x00DB8000-0x00DC0000] address[0x00DBD989] value[0x17 (023)]    
 
found 5926 occurrences, change value to: 33
search memory area[0x00DB8000-0x00DC0000] address[0x00DBFD88] value[0x21 (033)]    
 
found 1 occurrence! correct address for this value is 0x00C4335A
change value in memory at 0x00C4335A to: 99
done.

First you enter the known value, the trainer is searching it inside the memory, chances are high, that there are many occurrences of it, so you change the value inside the game and repeat the search with the new one. After ~2-4 iterations the correct location should be found and you can manipulate it.

edit: smaller changes

]]> http://sixserv.org/2010/07/26/memory-debugging-or-a-universal-game-trainer-with-python-and-ptrace/feed/ 0 Dynamic Loading of SDL http://sixserv.org/2010/05/21/dynamic-loading-of-sdl/ http://sixserv.org/2010/05/21/dynamic-loading-of-sdl/#comments Fri, 21 May 2010 05:58:15 +0000 apoc http://sixserv.org/?p=605
If you want to use the SDL library (or any other library for that matter) in your programs, you normally would just link with the library, for instance by -lSDL (GCC). Sometimes however, it would be more flexible to dynamically load the library at runtime. With dynamic loading, if your application supports alternative libraries (e.g.: [...]]]>

If you want to use the SDL library (or any other library for that matter) in your programs, you normally would just link with the library, for instance by -lSDL (GCC). Sometimes however, it would be more flexible to dynamically load the library at runtime. With dynamic loading, if your application supports alternative libraries (e.g.: GLUT SFML as an replacement for SDL), it can discover and use available libraries at runtime. The system your program is running on, just needs one of those libraries installed and can switch them without the need to recompile your program. This technique is probably most commonly used to load plugins into programs at runtime.

Theres a helpful Wikipedia article about Dynamic loading, they even describe how to load the SDL library in their examples. Besides that, theres an old discussion about that at lists.libsdl.org and an article at eaten by a grue (when good libraries go bad). However I didn’t find a complete example implementation for this, so I’m trying to create one with this article, although I’m not a very experienced C++ programmer.

The first thing to do is to load the library file, on POSIX/UNIX systems we do this with dlopen(), on windows we use LoadLibrary() and for closing dlclose() and FreeLibrary() respectively. The following code snippet for open/closing the library should work on both Linux and Windows systems:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#ifdef _WIN32
    #include <windows.h>
#else
    #include <dlfcn.h>
#endif
 
// [...]
 
#ifdef _WIN32
    HMODULE libhandle;
    libhandle = LoadLibrary("SDL.dll");
#else
    void *libhandle;
    libhandle = dlopen("libSDL.so", RTLD_LAZY);
#endif
 
// ... dlsym() and GetProcAddress() calls ...
 
#ifdef _WIN32
    FreeLibrary(libhandle);
#else
    dlclose(libhandle);
#endif

You need to link your programs to the dl library for this to work (such as -ldl in gcc).

The returned handle can be used to retrieve symbol addresses and then to convert them to function pointers. Theres dlsym() on POSIX and GetProcAddress() on Windows machines. The following code does that cross-platform for SDL_SetVideoMode():

1
2
3
4
5
6
7
8

SDL_Surface * (*p_SDL_SetVideoMode)(int, int, int, Uint32);
#ifdef _WIN32
    p_SDL_SetVideoMode = 
        (SDL_Surface * (*)(int, int, int, Uint32)) GetProcAddress(libhandle, "SDL_SetVideoMode");
#else
    p_SDL_SetVideoMode = 
        (SDL_Surface * (*)(int, int, int, Uint32)) dlsym(libhandle, "SDL_SetVideoMode");
#endif

You need to look at the header files (/usr/include/SDL/SDL_video.h) for the exact declaration (return and parameter types).

Theres a problem here, when casting from an void pointer that is returned by dlsym() to a function pointer which is prohibited by the C/C++ ISO standards. I’m using a simple explicit (C-style) cast here and in practice, I not even encountered a warning with modern compilers.

Johan Petersson has written an article (When standards collide: the problem with dlsym) about that problem in Scatter/Gather thoughts, I want to quote:

You probably noticed that I omitted the C-style cast from my earlier example. Alas, most C and C++ compilers will allow the conversion when you use a C-style cast. You may not even get a warning, even though it’s prohibited in ISO C as well as ISO C++. This kind of conversion is a common compiler extension. So common, in fact, that many people don’t realize it’s not in the standards.

The article is from 2004, I don’t know if the current C/C++ standards had changed any of that.

In the last code snippet theres an redundancy that can be resolved by using a typedef instead:

1
2
3
4
5
6
7

typedef SDL_Surface * (*Type_SDL_SetVideoMode)(int, int, int, Uint32);
Type_SDL_SetVideoMode p_SDL_SetVideoMode;
#ifdef _WIN32
    p_SDL_SetVideoMode = (Type_SDL_SetVideoMode) GetProcAddress(libhandle, "SDL_SetVideoMode");
#else
    p_SDL_SetVideoMode = (Type_SDL_SetVideoMode) dlsym(libhandle, "SDL_SetVideoMode");
#endif

Thats everything you need to call that function: (p_SDL_SetVideoMode)(...); The major problem here is that SDL has over 200 functions that “must” be declared and addressed this way. I’ve written a ruby script for Linux that does that for the SDL headers within /usr/include/SDL, at first it reads the symbol names directly from the libSDL.so shared library utilizing nm, then it parses the header files for the function declarations found by nm and generates the code for the pointer declaration and explicit casts (/dlsym calls) automatically.

I’ve created some example code that defines an abstract class DLLoader and an implementation DLLoaderSDL that includes an struct with the automatically generated function pointers etc. The test program loads the library and shows a SDL window for 3 seconds.
I’ve tested the program with GCC 4.5.0 (Linux), GCC 3.4.5 (Windows MinGW) and CL 14.0 (Windows VC++). I also added Makefiles for each of those compiler suites.

]]> http://sixserv.org/2010/05/21/dynamic-loading-of-sdl/feed/ 0 Zensursula: Teil 1 – DNS http://sixserv.org/2009/06/27/zensursula-teil-1-dns/ http://sixserv.org/2009/06/27/zensursula-teil-1-dns/#comments Sat, 27 Jun 2009 20:40:41 +0000 apoc http://sixserv.org/?p=447
“Sie werden sich noch wünschen wir wären Politikverdrossen” (@343max) Ich hatte in den letzten Wochen den Eindruck, als ob die gesamte Internet-Gemeinschaft in Deutschland Sturm lief, überall gab und gibt es nur ein Thema: Die Internetzensur Bestrebungen der großen Koalition. Dabei hatte man am Ende den Eindruck gegen eine Mauer von Unkenntnis, Ignoranz aber vielleicht [...]]]>

“Sie werden sich noch wünschen wir wären Politikverdrossen” (@343max)

zensursula-300x292Ich hatte in den letzten Wochen den Eindruck, als ob die gesamte Internet-Gemeinschaft in Deutschland Sturm lief, überall gab und gibt es nur ein Thema: Die Internetzensur Bestrebungen der großen Koalition. Dabei hatte man am Ende den Eindruck gegen eine Mauer von Unkenntnis, Ignoranz aber vielleicht auch einfach blanker böswilliger Berechnung einfach nichts ausrichten zu können.
Besonders Enttäuschend empfand ich die Medien, überraschend war es freilich nicht dass sie praktisch ausschließlich Parteipropaganda nachplapperten und die Mainstream Meinung nach dem Willen der Regierung formten. Von investigativem Journalismus jedenfalls war in den Holzmedien nichts zu sehen, das überlässt man offenbar anderen.

Ein wenig Ironisch ist es schon, ist doch gerade das Internet die einzige breit zugängliche alternative Informationsquelle(wie wir eindrucksvoll sehen konnten), die mit der jetzt beschlossenen Infrastruktur möglicherweise schon bald stark eingeschränkt wird. Dabei geht es auch um die Frage ob wir der Regierung soweit vertrauen, nach der Installation einer bis dato einmaligen Infrastruktur für Zensur, bei der Sperrung von Kinderpornographischen Inhalten zu bleiben. In den letzten Jahren hat uns die große Koalition keinen Grund geliefert das zu glauben.

Die eigentliche Kluft wie häufig Thematisiert, liegt nicht zwischen den Internet-Natives und den “Internet-Ausdruckern” sondern vielmehr in dem Teil der Bevölkerung der sich unabhängig Informiert und dem Teil, der den großen Medien und Agenturen(auch im Internet) blind vertaut und als einzige Informationsquelle zur eigenen Meinungsbildung heranzieht, also den überwiegenden Teil der Gesellschaft.

Gestern nun hat die EU die Zensur in China gerügt(so Merkwürdig wie das auch immer ist), demnach vergessen wir einfach alles was die EU-Länder sonst so treiben und beschäftigen uns nun, offensichtlich im Wohlwollen der EU, um die aktiven technischen Möglichkeiten der Umgehung jedweder Zensur-Infrastruktur, außerdem kann es nicht schaden die von den Zensoren eingesetzte Technologie mal etwas genauer zu beleuchten.

In diesem ersten Teil soll es um die Zensur durch DNS Manipulationen gehen.

Es ist noch die leichteste Form der Zensur, die Einstiegsdroge der Staaten sozusagen, denn DNS Manipulationen lassen sich Kinderleicht aushebeln was wohl schnell den Wunsch nach härteren Mitteln wecken dürfte. Bei dieser Form der Zensur installieren die ISP’s die Sperrlisten in ihren DNS-Servern, ist doch zumindest anzunehmen, das die Mehrheit der Internet Nutzer die Server ihres Providers verwenden, wobei das bei leibe nicht immer der Fall ist. So war und ist es schon immer möglich seinen eigenen DNS-Server zu betreiben. Jetzt wo man allen Grund hat den DNS-Servern der Provider zu misstrauen, ist das eine sehr praktikable Möglichkeit, zumindest für diejenigen die sich mit dem Internet auskennen.
Doch der Reihe nach, im Prinzip reicht es statt eines Domain-Namens in der Adresszeile die Ip-Adresse einzugeben um diese Zensur zu umgehen, besser ist es da schon einen alternativen DNS-Server zu verwenden, vorzugsweise im Ausland, aber auch der CCC und der Foebud stellen unzensierte DNS-Server (noch) frei zur Verfügung. Listen mit freien Servern gibt es z.B. bei Wikileaks, dem CCC oder die Server des Open NIC Projektes.

DNS Caching Server

Nützlich ist auch das Einrichten eines eigenen Caching DNS-Servers der zufällig aus einer Liste, öffentliche Servern abfragt. Ich verwende dafür den pdnsd, nicht zu verwechseln mit dem vollwertigen DNS-Server, PowerDNS. Je nach Distribution sollte sich die Installation einfach gestalten, z.B. reicht ein pacman -S pdnsd um mit Arch Linux den Server zu installieren. Jetzt sollte man sich die Beispiel Konfiguration kopieren und Anpassungen vornehmen. Hier eine mögliche Beispielkonfiguration, es muss nur die server_ip angepasst werden:

global {
        perm_cache=512000; # cache groesse in KB (hier "leicht" uebertriebene 500 MB)
        cache_dir="/var/cache/pdnsd";
        run_as="nobody";
        server_ip=10.0.0.4; # ANPASSEN
        status_ctl=on;
        paranoid=on; # prevents cache poisoning
        query_method=udp_tcp;
        min_ttl=15m; # min/max TTL
        max_ttl=4w;
        timeout=15; # global timeout 15 seconds
        neg_rrs_pol=auth;
        par_queries=2; # maximale parallele abfrage von servern
}
 
server { # ein paar oeffentliche server (alle getestet)
        label = "random";
        randomize_servers = on;
        ip = 85.214.73.63, # foebud
        204.152.184.76, # ISC (USA)
        213.73.91.35, # CCC
        194.95.202.198, # DFN
        58.6.115.43, # Westnet (Australien)
        82.229.244.191, # Frankreich
        88.191.77.10, # Frankreich
	216.87.84.209, # OpenNIC
	88.191.77.10; # OpenNIC
        timeout=10; # 10 sekunden maximal
        uptest=ping;
        ping_timeout=400; #ms
        interval=30m; # uptest der server per ping
}
 
# Unveraendert aus Sample Conf:
# This section is meant for resolving from root servers.
server {
        label = "root-servers";
        root_server = on;
        randomize_servers = on; # Give every root server an equal chance
                                # of being queried.
        ip =    198.41.0.4
        ,       192.228.79.201
        ,       192.33.4.12
        ,       128.8.10.90
        ,       192.203.230.10
        ,       192.5.5.241
        ,       192.112.36.4
        ,       128.63.2.53
        ,       192.36.148.17
        ,       192.58.128.30
        ,       193.0.14.129
        ,       198.32.64.12
        ,       202.12.27.33
        ;
        timeout = 5;
        uptest = query;         # Test availability using empty DNS queries.
        interval = 30m;         # Test every half hour.
        ping_timeout = 300;     # Test should time out after 30 seconds.
        purge_cache = off;
        exclude = .localdomain;
        policy = included;
        preset = off;
}
 
# ganz praktisch, damit braucht man nur eine einzige hosts Datei im ganzen LAN zu pflegen:
source { 
        owner=localhost;
        serve_aliases=yes;
        file="/etc/hosts";
}

Ich habe alle DNS Server getestet. Eventuell die Konfiguration noch auf die eigenen Anforderungen anpassen, eine Dokumentation findet ihr hier. Die /etc/resolv.conf noch auf die lokale IP-Adresse umstellen dann den Server (neu)starten. Jetzt sollte er funktionieren, testen kann man das z.B. mit nslookup oder: dig 4poc.org [IP des DNS], dig zeigt auch wie lange er zum resolven brauchte.

Um festzustellen welche DNS-Server verwendet werden habe ich ein kleines Skript geschrieben, eigentlich passt die Thematik(siehe Anmerkung im Script) nicht direkt zum Thema aber den folgenden Artikeln sei schon mal etwas vorgegriffen: nstest.4poc.org (DNS Tester, falls jemanden einen besseren Namen dafür einfällt nur her damit.)

]]> http://sixserv.org/2009/06/27/zensursula-teil-1-dns/feed/ 1 Ivacy VPN unter Linux: PPTP/OpenVPN und Socks5-Gateway http://sixserv.org/2009/01/24/ivacy-vpn-unter-linux-pptp-und-socks5/ http://sixserv.org/2009/01/24/ivacy-vpn-unter-linux-pptp-und-socks5/#comments Fri, 23 Jan 2009 23:42:15 +0000 apoc http://sixserv.org/?p=171
Die VPN Provider sprießen, dank der “Sicherheits-Politik” in Europa und den USA, wie Pilze aus dem Boden. Seit Juli 2008 gibt es Ivacy, einem durchaus interessanten VPN-Anbieter über den es möglich ist sich der Vorratsdatenspeicherung Europas zu entziehen. Hier geht es mir darum zu zeigen wie man Ivacy unter Linux nutzen kann, genauer gesagt wie [...]]]>

Die VPN Provider sprießen, dank der “Sicherheits-Politik” in Europa und den USA, wie Pilze aus dem Boden. Seit Juli 2008 gibt es Ivacy, einem durchaus interessanten VPN-Anbieter über den es möglich ist sich der Vorratsdatenspeicherung Europas zu entziehen. Hier geht es mir darum zu zeigen wie man Ivacy unter Linux nutzen kann, genauer gesagt wie man OpenVPN und PPTP unter Linux einrichtet, die Country-Selection Funktion von Ivacy nutzt und wie man einen Socks5 Proxy einrichtet der Verbindungen über Ivacy weiterleitet, dazu später mehr. Diese Anleitung sollte nicht nur mit Ivacy funktionieren, alle VPN-Anbieter bieten OpenVPN oder PPTP(das proprietäre VPN Protokoll von Microsoft).
Update: Habe einen OpenVPN-Abschnitt eingefügt.
Update 4.2.09@20:50: OpenVPN-Abschnitt überarbeitet.
Update 8.2.09@22:15: Artikel nochmals überarbeitet.
Update 21.4.09@22:00: Privoxy-Abschnitt eingefügt.

Bevor es losgeht sollte ich vielleicht noch erwähnen das es sich hierbei um keine Anleitung für Linux-Anfänger oder Ubuntu/Suse-”Profis” handelt. *g*

0. Einleitung und Sicherheit

Ich stelle die Verbindung zu Ivacy über eine extra eingerichtete Virtuelle Maschine her, die auf dem VMWare Server meiner 24/7 Kiste läuft. Darauf habe ich eine minimale Arch Linux-Installation am laufen. Dieser Server dient mir als Socks5-Gateway ins Ivacy VPN-Netz.

In wie weit Ivacy auch Genial ist, bleibt die Frage der Vertrauenswürdigkeit eines VPN-Dienstleisters bestehen, insbesondere wenn er so günstig wie Ivacy ist. Die Frage muss sich jeder selbst stellen und daraufhin entscheiden welche Art von Traffic er über das VPN schicken will. Ein Socks5-Gateway erlaubt es sehr viel genauer zu bestimmen und zu kontrollieren was über Ivacy ins Internet geht.

0.1. NAT und DoubleVPN

Bei Ivacy bekommt man keine statische oder dynamische IP. Vielmehr bekommt jeder die gleiche, per NAT werden alle Anfragen nach außen geleitet. Wenn sich so hunderte User hinter einer einzigen IP verbergen, verhilft das allen zu einem erheblichen Grad an Anonymität. Benötigt man einen offenen Port der zu einem Geforwarded wird, so kann man diesen einfach auf der Webseite anfordern und bekommt einen zufälligen zugewiesen.
Außerdem ist es möglich seinen Traffic über 2 Hops von Ivacy zu leiten um so die Anonymität noch zusätzlich zu erhöhen.

1. OpenVPN

OpenVPN muss in einer Version >= 2.1 installiert sein(!). Je nach Distribution installieren und darauf achten das ein tun-Device entsteht. In Arch Linux muss man sich selbst um das erstellen kümmern. Im Windows XP(nicht im Linux Abschnitt warum auch immer) gibt es die notwendigen Konfigurations-Dateien sowie Zertifikate(!). Die Konfigurationsdatei für OpenVPN kann praktisch übernommen werden:

client
dev tun
proto udp
remote openvpn.ivacy.com 1194
resolv-retry infinite
nobind
persist-key
persist-tun
ca /etc/openvpn/ivacy-ca.crt
cert /etc/openvpn/ivacy-client.crt
key /etc/openvpn/ivacy-client.key
tls-auth /etc/openvpn/ivacy-tls.key 1
ns-cert-type server
comp-lzo
verb 3
# Mit Passwort Datei: (geht nur wenn openvpn
# mit "--enable-password-save" kompiliert wurde!):
auth-user-pass /etc/openvpn/password
# sonst so:
auth-user-pass
redirect-gateway
reneg-sec 0
up /etc/openvpn/ivacy-up.sh
down /etc/openvpn/ivacy-down.sh

Die /etc/openvpn/password-Datei enthält Username – neue Zeile – Password, doch wie schon erwähnt kann es sein, das dies nicht funktioniert wenn openvpn ohne “–enable-password-save” kompiliert wurde. Danach noch die Zertifikat-Dateien erstellen die es auf der oben erwähnten Seite auf ivacy.com gibt und die richtigen Berechtigungen(600) geben.

Die up und down Scripte können wohl auch durch /etc/openvpn/update-resolv.conf ersetzt werden(sofern vorhanden), siehe dazu auch den Artikel auf Geekosphere. Ich verwende die Scripte auch dazu um den Socks-Daemon zu starten/beenden. Hier die Scripte:

/etc/openvpn/ivacy-up.sh:

#!/bin/bash
 
cp /etc/resolv.conf /etc/resolv.conf.last
echo "nameserver 1.254.2.2" > /etc/resolv.conf
echo "nameserver 1.254.2.3" >> /etc/resolv.conf
 
/usr/sbin/sockd -D

/etc/openvpn/ivacy-down.sh:

#!/bin/bash
 
cp /etc/resolv.conf.last /etc/resolv.conf
killall -9 sockd

Die DNS-Server können der Tabelle unten entnommen werden, jedoch ist mir nur ein OpenVPN-Server von Ivacy bekannt, eben der in Russland, deshalb ist auch keine Country-Selection über OpenVPN möglich! (höchstens über die Double-VPN Funktion) Die OpenVPN Verbindung startet man darauf mit:

openvpn --script-security 3 system --config /etc/openvpn/ivacy.conf

Nicht vergessen in der /etc/socksd.conf-Datei, “external” auf das verwendete tun-Device(tun0 z.B.) einzustellen.

2. PPTP

Hierfür braucht es pptp(nicht den Server, den Client!), in Arch-Linux heisst das Paket “pptp-linux” in Ubuntu “pptpclient” und auch sonst gibt es das bestimmt bei jeder Distribution als Paket. Also zuerst vergewissern wir uns das pptp installiert ist:

$ pptp --version
pptp version 1.7.2

Die Konfiguration besteht nur 2 Dateien, zunächst /etc/ppp/chap-secrets:

[Username] PPTP [Password] *

Dein Benutzername und Passwort von Ivacy eintragen. /etc/ppp/peers/ivacy

pty "pptp pptp2.ivacy.com --nolaunchpppd"
name [Username]
remotename PPTP
require-mppe-128
file /etc/ppp/options.pptp

Auch hier den Usernamen ändern. Die Verbindung kann mit

$ pon ivacy debug dump logfd 2 nodetach

getestet werden. Wird die local und remote IP angezeigt funktioniert alles.

2.1. Country Selection

Ivacy ermöglicht es den VPN-Server nach Land auszuwählen. Zur Verfügung steht USA, England und Russland. Auswählen kann man das unter Windows mit ihren Ivacy Monitor(und den anderen Programmen von Ivycy). Der PPTP-Host bestimmt das Land:

pptp2.ivacy.com	Russland
pptp3.ivacy.com	England
pptp4.ivacy.com	USA

Dies also entsprechend oben anpassen, je nach aus welchem Land man ins Internet will. (VDS gilt übrigens auch in England)

Die wichtigsten Einstellungen, das kann sich natürlich alles ändern und man sollte das entsprechend ändern sofern ifconfig ppp0 eine andere IP zeigt:
Russland:
PPTP-Server: 213.232.208.167 (pptp2.ivacy.com)
Gateway: 1.254.2.167
DNS Primary: 1.254.2.2
DNS Secondary: 1.254.2.3

England:
PPTP-Server: 81.222.64.214 (pptp3.ivacy.com)
Gateway: 1.254.3.131
DNS Primary: 1.254.3.2
DNS Secondary: 1.254.3.3

USA:
PPTP-Server: 208.88.226.38 (pptp4.ivacy.com)
Gateway: 1.254.4.128
DNS Primary: 1.254.4.2
DNS Secondary: 1.254.4.3

2.2. Verbindung herstellen

Hier ein Auszug wie das Verbinden funktionieren kann(mit pptp2.ivacy.com, IP: 213.232.208.167):

$ route del -net default # Das Entfernen des Default-Gateways
# Der PPTP-Server soll über den eben gelöschten Default-Gateway geroutet werden:
$ route add -host 213.232.208.167 gw 10.0.0.1
$ pon ivacy # Die PPTP-Verbindung wird hergestellt
# Nach ein paar Sekunden sollte die Verbindung aufgebaut sein...
$ ifconfig ppp0
ppp0      Link encap:Point-to-Point Protocol
          inet addr:1.2.127.104  P-t-P:1.254.2.167  Mask:255.255.255.255
          UP POINTOPOINT RUNNING NOARP MULTICAST  MTU:1406  Metric:1
          RX packets:21 errors:0 dropped:0 overruns:0 frame:0
          TX packets:24 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:3
          RX bytes:2774 (2.7 Kb)  TX bytes:1189 (1.1 Kb)
# Die P-t-P IP wird als neuer Default-Gateway eingetragen:
$ route add -net default gw 1.254.2.167
$ echo "nameserver 1.254.2.2" > /etc/resolv.conf # Eintragen der DNS Adressen:
$ echo "nameserver 1.254.2.3" >> /etc/resolv.conf
# Noch als kleiner Hint:
$ route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
213.232.208.167 10.0.0.1        255.255.255.255 UGH   0      0        0 eth0
1.254.2.167     0.0.0.0         255.255.255.255 UH    0      0        0 ppp0
10.0.0.0        0.0.0.0         255.255.255.0   U     0      0        0 eth0
0.0.0.0         1.254.2.167     0.0.0.0         UG    0      0        0 ppp0

Die Verbindung sollte jetzt stehen. Ich bin ziemlich sicher das das alles viel einfacher geht, aber mir erschien dieser Weg als der logischste, natürlich schreibt man sich das alles in ein entsprechendes Shell-Skript. (Update: siehe Unten, ivacyConnect.rb)
Hier noch das Gegenstück, das beenden der Verbindung und umleiten der Route:

$ poff ivacy
$ route add -net default gw 10.0.0.1 # Bei mir ist 10.0.0.1 der Gateway, entsp. ändern
$ echo "nameserver 10.0.0.1" > /etc/resolv.conf # Was auch immer euer DNS ist.

2.3. Connect Script

Ich dachte ich stelle auch mal mein Script online mit dem ich die Ivacy Verbindung aufbaue: ivacyConnect.rb
Das ganze ist ein Ruby Script, muss natürlich als root ausgeführt werden. Außerdem sollten die Werte am Anfang an das eigene Netzwerk angepasst werden. Es basiert darauf das in der /etc/ppp/peers/ivacy als Hostnamen für den PPTP-Server, “pptp.ivacy.com” eingetragen ist. Je nach Land ändert es dann die IP dieser Domain über die /etc/hosts Datei.

3. Socks v5 Server

Der Vorteil eines solchen Socks5 > Ivacy Gateways liegt einfach darin, das man pro Anwendung entscheiden kann ob sie über Ivacy gehen soll oder nicht. Dazu im nächsten Teil mehr, erstmal zum Einrichten des Socks5 Servers. Zum Einsatz kommt Dante, einem einfach zu konfigurierenden Socks-Server. (Bei Arch Linux ist Dante im AUR zu finden.) /etc/sockd.conf:

logoutput: syslog stdout
internal: eth0 port = 1080
external: ppp0 # -- bei OpenVPN zu tun0 oder besser gesagt tunN ändern.
 
method: none
clientmethod: none
extension: bind
 
connecttimeout: 120   # on a lan, this should be enough if method is "none".
iotimeout: 0 # or perhaps 86400, for a day.
 
client pass {
        from: 10.0.0.0/8 port 1-65535 to: 0.0.0.0/0
}
pass {
        from: 10.0.0.0/8 to: 0.0.0.0/0
        command: bind
        log: connect error
}
pass {
        from: 0.0.0.0/0 to: 10.0.0.0/8
        command: bindreply udpreply
        log: connect error
}
pass {
        from: 10.0.0.0/8 to: 0.0.0.0/0
        protocol: tcp udp
}

Da der Server ohnehin nur in meinem LAN erreichbar ist, verzichte ich auf jedwede Authentifikation. Gestartet wird der Socks5-Dante mit:

$ sockd
$ sockd -d # Debug Mode, nützlich bei fehlerhafter Konfiguration

3.1. Firefox

Von Haus aus kann Firefox Socks Proxy verwenden. In den Netzwerk Einstellungen also die IP des VPN-Gateways und 1080 als Port einstellen. DNS-Requests werden per Default nicht über den Socks geleitet. Um dies zu aktivieren, verändert man die Config-Variable “network.proxy.socks_remote_dns” über “about:config”.
Eine weitere Möglichkeit ist z.B. das FoxyProxy-AddOn. Damit kann sehr schnell der Socks aktiviert werden, oder zwischen eingestellten Proxys ausgewählt werden. Wichtig ist auch hier die DNS über Socks Funktion zu aktivieren. Zu finden in den FoxyProxy Options -> Global Settings -> Use SOCKS proxy for DNS lookups.

FoxyProxy Firefox-Plugin

Um sich nicht durch Cookies usw. zu verraten empfiehlt es sich ein neues Profil fürs Surfen per VPN anzulegen. Praktisch ist es auch einen zweiten Firefox mit Proxy laufen zu lassen.

3.2. TSocks

Das kleine Programm tsocks erlaubt das transparente Umleiten des Traffics. Nachdem es eingerichtet ist kann man so jedes beliebige Programm über den Socks5 Ivacy Gateway laufen lassen. Nachdem man tsocks installiert hat muss noch folgende Konfigurationsdatei angelegt werden:

/etc/tsocks.conf

local = 10.0.0.0/255.255.255.0
 
server = 10.0.0.30
server_port = 1080
server_type = 5

Jedes beliebige Programm kann jetzt über den Socks-Server geleitet werden, auch dann wenn es selbst gar keinen Socks-Proxy unterstützt. Dazu wird einfach tsocks vorangestellt, z.B.:

tsocks wget http://google.com/

Zu beachten ist, das die DNS-Aufrufe weiterhin über den in resolv.conf eingestellten DNS-Server laufen und so neben dem kleinen Anonymitätsverlust, auch die internen Ivacy-Seiten(.site) nicht aufgelöst werden können.

4. Privoxy: HTTP Proxy Server

Viele Anwendungen unterstützen keine Socks5 Proxys, daher ist ein gewöhnlicher HTTP-Proxy manchmal ganz praktisch. Privoxy kennen bestimmt viele in Verbindung mit Tor, für unsere VPN-Gateway VM muss lediglich die folgende Zeile in der Konfiguration(/etc/privoxy/config) geändert werden:

listen-address  127.0.0.1:8118
ändern auf die lokale IP:
listen-address  10.0.0.30:8118

Das war dann schon alles zum Thema Ivacy, ich werde den Artikel auch in Zukunft überarbeiten wenn mir neues dazu einfällt. Anmerkungen und Feedback ist natürlich wie immer gern gesehn, ich hoffe einigen Linux-Usern damit geholfen zu haben.

]]> http://sixserv.org/2009/01/24/ivacy-vpn-unter-linux-pptp-und-socks5/feed/ 32 xinetd: info script http://sixserv.org/2009/01/22/xinetd-info-script/ http://sixserv.org/2009/01/22/xinetd-info-script/#comments Thu, 22 Jan 2009 18:00:29 +0000 apoc http://sixserv.org/?p=142
Ich wollte von unterwegs aus den Status meines Heimservers abrufen können. Dabei ging es mir vorallem um die Temperatur von CPU, Mainboard und den Festplatten. Der auf sixserv.org laufende rbot(im Freenode idled der in #sixserv) soll auf Kommando den Status anzeigen. Soweit so gut. Ein kleines Ruby-Skript das auf dem Server zuhause läuft erfasst die [...]]]>

Ich wollte von unterwegs aus den Status meines Heimservers abrufen können. Dabei ging es mir vorallem um die Temperatur von CPU, Mainboard und den Festplatten. Der auf sixserv.org laufende rbot(im Freenode idled der in #sixserv) soll auf Kommando den Status anzeigen. Soweit so gut. Ein kleines Ruby-Skript das auf dem Server zuhause läuft erfasst die Temperaturen per “sensors” und “hddtemp”. Der xinetd-Daemon konfigurierte ich daraufhin so das auf einen Port das Skript gebunden wird. Es erwartet bevor es die Daten übermittelt ein Passwort, einfach zum zusätzlichen Schutz auch wenn das vielleicht gar nicht nötig ist. Jemand der einen Portscan durchführt könnte eben so informationen zum System gelangen, die Passwortabfrage verhindert dies.

Zunächst zu dem Ruby-Script(z.B. /opt/botinfo.rb):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#!/usr/bin/ruby
 
i = Kernel.gets
if i.chomp != 'DASGEHEIMEPASSWORT' then
	# puts 'Wrong Password'
	exit
end
 
puts `uptime`.lstrip
 
# HDD Temps:
matches = `cat /proc/partitions`.scan /([s|h]d[a-z])/
matches.uniq!
matches.each do |disk|
	print "#{disk}: #{`hddtemp -n /dev/#{disk}`.chomp}.0*C (#{$1}GB) "
end
puts 
 
systemp = `sensors`
 
temp1 = systemp.scan /CPU Temp:    \+([0-9]+)\.0.C/
temp2 = systemp.scan /M\/B Temp:    \+([0-9]+)\.0.C/
 
puts "System: #{temp2[0]}.0*C #{temp2[1]}.0*C | CPUs: #{temp1[0]}.0*C #{temp1[1]}.0*C"

Hier muss natürlich sensors und hddtemp installiert sein, aber dieses Script kann praktisch alles mögliche an Informationen sammeln und ausgeben.
Die Konfiguration von xinetd gestaltet sich sehr einfach, in dem Verzeichnis /etc/xinetd.d einfach eine neue Datei für das Script erstellen(z.B. “botinfo”):

1
2
3
4
5
6
7
8
9
10
11

service botinfo
{
    disable         = no
    port            = 8888
    socket_type     = stream
    protocol        = tcp
    wait            = no
    user            = apoc
    server          = /opt/botinfo.rb
    type            = unlisted
}

Den Port, User und den Skript Pfad entsprechend anpassen und xinetd neu starten. Mit netcat kann es man danach testen:

1
2
3
4
5

$ nc localhost 8888
DASGEHEIMEPASSWORT
18:40:35 up 3 days, 41 min,  4 users,  load average: 0.00, 0.02, 0.20
sda: 30.0*C (10GB) sdb: 29.0*C (10GB)
System: 39.0*C 38.0*C | CPUs: 37.0*C 36.0*C

Der Port muss ggf. vom Router geforwarded werden damit ein Entfernter Server darauf zugreifen kann. Auch ein dyndns ist hilfreich, sofern man über keine statische IP verfügt. Ein einfaches rbot-Plugin um diese Daten vom irc aus abzufragen sieht z.B. so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

require 'socket'
 
class BotinfoPlugin < Plugin
  def help(plugin, topic="")
    'info => return system information'
  end
 
  def info(m, params)
    sock = TCPSocket.new('heimserver.dyndns.org', 8888)
    sock.puts('DASGEHEIMEPASSWORT')
    m.reply sock.recv(1024)
    sock.close
  end
end
plugin = BotinfoPlugin.new
plugin.map 'info'

Die Daten können ebenfalls von einem PHP-Script aus abgefragt werden. Keines Beispiel:

1
2
3
4
5
6
7
8
9

<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
socket_connect($socket, "heimserver.dyndns.org", "8888");
 
$pass = "DASGEHEIMEPASSWORT\n\n";
socket_write($socket, $pass, strlen($pass));
 
echo socket_read($socket, 2048);
?>

Vielleicht findet das ja irgendjemand interessant ;)

]]> http://sixserv.org/2009/01/22/xinetd-info-script/feed/ 2 opengl-background unter compiz http://sixserv.org/2008/09/19/opengl-background-unter-compiz/ http://sixserv.org/2008/09/19/opengl-background-unter-compiz/#comments Fri, 19 Sep 2008 15:53:50 +0000 nks http://sixserv.org/?p=103
Eine weitere nette Spielerei für Leute mit zu viel Ressourcen Ich hab sie nicht aber das ganze läuft auch auf einem 700Mhz Duron flüssig. Ihr benötigt “xscreensaver” (und auch das Paket “fireflies” falls ihr es wie auf den Screenshots haben wollt, wobei sich “pong” auch ganz gut macht) und “xwinwrap” (xwinwrap does teh magic) nks@hydra [...]]]>

Eine weitere nette Spielerei für Leute mit zu viel Ressourcen :D

Ich hab sie nicht aber das ganze läuft auch auf einem 700Mhz Duron flüssig.

Ihr benötigt “xscreensaver” (und auch das Paket “fireflies” falls ihr es wie auf den Screenshots haben wollt, wobei sich “pong” auch ganz gut macht) und “xwinwrap” (xwinwrap does teh magic)

nks@hydra ~ $ nice -n 15 /usr/bin/xwinwrap -ni -argb -fs -s -st -sp -b -nf -- /usr/lib/misc/xscreensaver/fireflies -window-id WID

Das ganze sieht dann so aus:

Für mehr Infos:

Man kann neben xscreensaver auch Videos als Hintergrund laufen lassen

nks

]]> http://sixserv.org/2008/09/19/opengl-background-unter-compiz/feed/ 3 software-kvm mit synergy http://sixserv.org/2008/09/19/software-kvm-mit-synergy/ http://sixserv.org/2008/09/19/software-kvm-mit-synergy/#comments Fri, 19 Sep 2008 14:54:05 +0000 nks http://sixserv.org/?p=98
Mir ist gestern die Fernbedienung meiner Sourround-Anlage auf den Boden gefallen – jetzt ist sie unbrauchbar. Also dachte ich mir: “Hey, mach doch den eee-pc zu deiner neuen Fernbedienung!”. Also wenn ich im bett liege und die lautstärke regeln will, schnell per ssh auf den Rechner verbinden und alsamixer nutzen. Aber dafür is der eee [...]]]>

Mir ist gestern die Fernbedienung meiner Sourround-Anlage auf den Boden gefallen – jetzt ist sie unbrauchbar. Also dachte ich mir: “Hey, mach doch den eee-pc zu deiner neuen Fernbedienung!”.

Also wenn ich im bett liege und die lautstärke regeln will, schnell per ssh auf den Rechner verbinden und alsamixer nutzen. Aber dafür is der eee ja schon bisl overkill. Dann erinnerte ich mich an meine Experimente vor einem Jahr die beiden desktop-pcs miteinander zu verbinden.

Ich hatte es auch mit synergy versucht, aber es war ziemlich buggy. Aber die neue Version läuft wesentlich stabiler. Also schnell auf allen 3 boxen synergy gemerged und ab an die config:

# nks's synergy configuration file
# eeerr0r is the synergy-server
# infected and hydra are the clients
 
section: screens
infected:
hydra:
eeerr0r:
end
 
section: links
# larry is to the right of moe and curly is above moe
infected:
right = eeerr0r
eeerr0r:
left = infected
right = hydra
hydra:
left = eeerr0r
end
section: aliases
infected:
192.168.178.30
hydra:
192.168.178.32
eeerr0r:
192.168.178.25
end

Das ganze dann auf dem System welches Tastatur und Maus bereitstellen soll unter “/etc/synergy.conf”
und dann ab in die shell:

nks@eeerr0r ~ $ synergys -f --config /etc/synergy.conf
nks@infected ~ $ synergyc -f eeerr0r
nks@hydra ~ $ synergyc -f eeerr0r

Und schon kann ich vom eee-pc aus beide Rechner kvm-style fernsteuern :D
das ganze funktioniert auch unter windows und mac os.

Besonders schön is das ganze in Kombination mit compiz weil man dann vom Bett/anywhere aus ranzoomen kann :D

Informationen & links:

ps: chase & status releasen demnächst ihr neues Album, zwar ziemlich die uk-kommerz schiene, aber “hurt you” und “pieces” laufen atm ja fast in jedem set, also man kann gespannt sein (wobei “hurt you” auch auf dem neuem Album ist)

pps:Ich hatte damals auch mit xdmx ruexperimentiert, hehe.. vll. probier ich demnächst auch wieder etwas damit rum, allerdings mit compiz etwas zu lahm, in Kombination mit chromium funktioniert es vll besser.

nks

]]> http://sixserv.org/2008/09/19/software-kvm-mit-synergy/feed/ 0 kernel mode sockets part 2 (the clean way) http://sixserv.org/2008/08/30/kernel-mode-sockets-part-2-the-clean-way/ http://sixserv.org/2008/08/30/kernel-mode-sockets-part-2-the-clean-way/#comments Sat, 30 Aug 2008 00:34:27 +0000 nks http://sixserv.org/?p=10
Version 0.3 -  23.01.2009 Willkommen zu teil 2 der linux kernel mode socket Serie. Nun befassen wir uns mit einem sauberem weg der socketcalls vom kernel aus. Auch hierfür gibt es noch andere Wege. In einem der nächsten Teile bauen wir uns eine socket()-Funktion selber, aber nun zum sauberem socket Auch hier müssen wir wieder [...]]]>

Version 0.3 -  23.01.2009

Willkommen zu teil 2 der linux kernel mode socket Serie. Nun befassen wir uns mit einem sauberem weg der socketcalls vom kernel aus. Auch hierfür gibt es noch andere Wege. In einem der nächsten Teile bauen wir uns eine socket()-Funktion selber, aber nun zum sauberem socket :D

Auch hier müssen wir wieder set_fs/get_fs (man kann sie auch weglassen, aber in diesem Fall garantiere ich für NICHTS, bzw das Modul lässt sich 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 müssen wir uns nicht extra schreiben, hab ich zwischenzeitlich herausgefunden in der “linux/inet.h” gibt es in_aton() :D

Die Hauptschwierigkeit besteht in den neuen Strukturen iovec und msghdr. Die ich allerdings anhand von Kommentaren erklären werde, soweit wichtig, bzw unter den beiden links steht alles was man wissen muss (obwohl es nicht spezifisch um die linux Strukturen geht).

Ab an den 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;
	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;
	msg.msg_control = NULL;
	msg.msg_name = NULL;
	msg.msg_namelen = 0;
 
	old_fs = get_fs();
	set_fs(KERNEL_DS);
 
	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"&gt;
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" lang="de-DE">
<head profile="http://gmpg.org/xfn/11"&gt;
<title>sixserv blog</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<meta name="description" content="welcome to teh #sixserv!" /&gt;
<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 nächsten teil der kernel mode Serie :D

nks

quellen:

ps:
cuil.com und metager2.de lassen sich beide in die Suchleiste integrieren (klickt einfach auf den namen dann fragt euch FF). Nach einigem testen gefällt mir metager2 wesentlich besser weil es VIEL mehr findet. Allerdings gefällt mir die Aufmachung von cuil.com, ich sehe noch einiges an potenzial.

pps:
Mal wieder ein musikalischer Tipp:
http://www.myspace.com/blue_nine

edit: Unterschiede zu Version 0.1 haben nur mit der Rechtschreibung zu tun!

]]> http://sixserv.org/2008/08/30/kernel-mode-sockets-part-2-the-clean-way/feed/ 3 kernel mode sockets part 1 (the dirty way) http://sixserv.org/2008/08/29/kernel-mode-sockets-part-1-the-dirty-way/ http://sixserv.org/2008/08/29/kernel-mode-sockets-part-1-the-dirty-way/#comments Thu, 28 Aug 2008 23:38:53 +0000 nks http://sixserv.org/?p=8
Version 0.3 – 23.01.2009 Kernel mode sockets sind hoch-interessant. Im ersten teil befasse ich mich mit einer einfachen Implementierung eines ziemlich simplen kernel mode sockets, das ist nicht der Weg wie man es machen sollte allerdings hilft es erstmal dem grundsätzlichem Verständnis von lkm – also kernel modulen unter linux. Es ist natürlich trotzdem möglich [...]]]>

Version 0.3 – 23.01.2009

Kernel mode sockets sind hoch-interessant. Im ersten teil befasse ich mich mit einer einfachen Implementierung eines ziemlich simplen kernel mode sockets, das ist nicht der Weg wie man es machen sollte allerdings hilft es erstmal dem grundsätzlichem Verständnis von lkm – also kernel modulen unter linux.

Es ist natürlich trotzdem möglich diesen Code in einem rootkit zu verwenden etc. aber ich finde das dieser Code nichts in einem produktiven Umfeld zu suchen hat, man öffnet keine Dateien aus derm kernel mode.

Wir beginnen mit den Basics eines lkm.

Zu erst das klassische “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 über den syscall “socketcall()” erstellen. Um syscalls aus dem kernel aufrufen zu können gab es bis kernel 2.6.19 die syscall macros (für alle mit einem neuerem kernel habe ich einen kleinen header mit den macros hoch geladen), allerdings kann man eigtl keine syscalls vom kernel aus machen, damit wir das können müssen wir aus dem kernel-space Adressraum in den user space Adressraum, das geschieht hier per set_fs(). und schon kann man userspace calls ausführen.

/*
*  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 können 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 Ausgabe erscheint:

++ Kernel Mode Socket is up …

Aber nur ein socket alleine ist ja bekanntlich ziemlich langweilig :D
Also verbinden wir uns mit einem http Server. Hierfür müssen wir noch ein paar Anpassungen an unserem bestehendem Code tätigen:

/*
*  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;
}

Wieder 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 Übergabe der Parameter verwenden wir ein char array bzw zwei da recv und send jeweils 4 Argumente haben.

Die syscall macros hab ich für euch hochgeladen

quellen:

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

nks

ps:
benutzt öfters mal google-alternativen.. :D   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…

]]> http://sixserv.org/2008/08/29/kernel-mode-sockets-part-1-the-dirty-way/feed/ 1