Die Situation

Funfact vor weg: Notebooksbilliger.de hat zum CD-laufwerklosen Laptop eine Treiber-CD mitgeliefert. Der Sinn ergibt sich mir bis jetzt nicht. Zudem war auf dem „betriebssystemlosen“ Laptop ein Linpus-Linux (Chinalinux) vorinstalliert.

Nichtsdestotrotz war das Ziel ein Windows auf diesem Laptop zu installieren. Der Versuch eine Windows-ISO auf einem USB-Stick bootbar zu machen klappte zunächst, jedoch meldete die Installationsroutine der USB-Stick könne nicht gefunden werden.

Der Workaround

Da es schon spät abends war, hatte ich auch keine Lust mehrere solcher Windows-USB-Sticks zu erstellen. Eine alternative Lösung musste her.

Da erinnerte ich mich an den Google-CTF, in dem man mit dem NBD-Protokoll arbeiten musste.

Folgende Idee kam mir dabei in den Kopf:

• Auf beiden Laptops Linux starten
• Festplatte über NBD freigeben und einhängen
• Mit VirtualBox Windows auf die freigegebene Festplatte installieren

Das hört sich kompliziert an, hatte am Ende aber einige Vorteile, da Windows 7 leider keine passenden USB- bzw. Netzwerktreiber für den Laptop mitbrachte:

• USB-Zugriff über VirtualBox
• Netzwerk-Zugriff über VirtualBox
• CD-Zugriff über VirtualBox

Die Umsetzung

Zunächst bootet man auf zwei Rechnern Linux. In meinem Fall habe ich für den neuen Laptop (A) ein Archlinux-Livesystem genutzt, da auf meinem Laptop (B) bereits Archlinux läuft. Andere Distributionen sollten für dieses Vorhaben auch nutzbar sein, allerdings muss wahrscheinlich ein andersnamiges Paket installiert werden.

Der erste Schritt besteht darin, auf beiden Laptops NBD zu installieren. Unter Archlinux heißt das Paket „nbd“.

sudo pacman -S nbd

Als nächstes baut man ein Netzwerk zwischen beiden Rechnern auf. Dazu habe ich diese mit einem LAN-Kabel direkt verbunden. Es ist aber auch möglich einen Router und automatische IP-Konfiguration (DHCP) zu nutzen.

Auf Laptop B:

sudo ip a a 192.168.50.1/16 dev enp2s0f0

wobei „enp2s0f0“ euer Netzwerkinterface ist.

Auf Laptop A:

sudo ip a a 192.168.50.2/24 dev enp2s0
sudo ip r a 192.168.50.0/24 via 192.168.50.1 dev enp2s0

Danach sollten beide Geräte sich pingen können.

Als nächstes gibt man in diesem Netzwerk die Festplatte von A frei:

nbd-server -d -C /dev/null 1337 /dev/sda

Parameter:

• -d : Debugmodus, Prozess geht nicht in den Hintergrund
• -C /dev/null: Keine Konfigurationsdatei laden
• 1337: Port, auf dem die Freigabe läuft
• /dev/sda: Festplatte, die freigegeben werden soll

Auf B bindet man das Gerät entsprechend ein:

nbd-client -nofork 192.168.50.2 1337 /dev/nbd0

Parameter:

• -nofork: Nicht in den Hintergrund gehen
• 192.168.50.2: IP von A
• 1337: Port auf dem A die Freigabe hat
• /dev/nbd0: 1. Freigabe von A.

Als nächstes braucht man ein wenig VirtualBox-Magic, um VirtualBox die Netzwerkfreigabe als eigenständige Festplatte vorzugaukeln:

VBoxManage internalcommands createrawvmdk -filename /tmp/laptop-windows.vmdk -rawdisk /dev/nbd0 

Parameter:

• -filename: Pfad zur neuen vmdk-Datei („Symlink“)
• -rawdisk: Pfad zur echten Festplatte, nämlich der Netzwerkfreigabe, also der Festplatte auf A

Nun kann man in VirtualBox eine neue virtuelle Maschine anlegen. Dabei gibt man als „vorhandene Festplatte“ den Pfad „/tmp/laptop-window.vmdk“ an. Alle Änderungen die man in der virtuellen Maschine vornimmt, werden dann über das Netzwerk auf die Festplatte von Laptop A geschrieben.

Problem gelöst und Windows endlich installiert :)

~ Sebastian

Ich gehe in dieser Anleitung davon aus, dass VirtualBox installiert ist.

Vorbereitung

Als Erstes steckt man einfach den entsprechenden USB-Stick rein und kann dann z.B. mit dem Befehl dmesg schauen wie es heißt, bei mir heißt der Stick zum Beispiel sdc (oft heißt er auch sdb), also kommt am Ende von der dmeseg-Ausgabe etwa sowas raus:

 [sdc] Attached SCSI removable disk 
 

Jetzt kann man den USB-Stick seinem Benutzer zuweisen.

sudo chown  [dein Benutzername] /dev/sdc

Jetzt kann man den USB-Stick zu einem Virtual Disk Image (.vmdk) machen

$ VBoxManage internalcommands createrawvmdk -filename /tmp/test-usb.vmdk -rawdisk /dev/sdc

RAW host disk access VMDK file /tmp/test-usb.vmdk created successfully.
#die .vdi für den USB-Stick liegt jetzt in /tmp

Jetzt hat man alles Vorbereitet und kann die VM erstellen.

Die VM erstellen

Die VM kann man am einfachsten mit rum klicken erstellen.

Man öffnet den Virtual Box Manager und erstellt eine neue Maschine:

Auf Neu klicken

Danach macht man optimaler Weise Einstellungen, über das erwartete System, bei den anderen Optionen kann man die Standardeinstellungen übernehmen. Als Festplatte muss man dann natürlich sein in den vorigen Schritten erstelltes .vmdk im /tmp auswählen. Dann nur noch erstellen und es solte funktionieren.

Das richtige Logo auswählen, bei mir Arch

Egal, weiterklicken

/tmp/test-usb,vmdk auswählen

Freuen, es funktioniert

Was ist Icecast2 ?

Grob gesagt ist Icecast eine Software mit der man Streams (meist Musik) im Internet bereitstellen kann. Zum Beispiel können so Podcasts an größere Zuhörermengen verteilt werden, oder Hobby-DJs lassen ihre Zuhörer das Set live genießen.

Die Installation von Icecast2

Es gibt – wie fast immer – zwei Wege der Installation. Einerseits kann man Icecast2 direkt aus den Paketquellen der meisten Distributionen (Linux) installieren. Das klappt oft mit dem folgenden Befehl:

sudo apt-get install icecast2

Andererseits kann man sich den Quelltext herunterladen und diesen selbst kompilieren. Letzteres habe ich getan, sodass ich mein Vorgehen folgend beschreiben werde.

Als erstes wechseln wir in den RAM und erstellen einen temporären Ordner:

cd /tmp && mkdir icecast && cd icecast

Danach laden wir den Quelltext herunter und entpacken diesen:

wget http://downloads.xiph.org/releases/icecast/icecast-2.4-beta3.tar.gz .
tar xfv icecast-2.4-beta3.tar.gz
rm icecast-2.4-beta3.tar.gz
cd icecast-2.3.99.3

Die Versionsnummern können sich in der Zukunft ändern. Gegebenenfalls müssen diese angepasst werden. 

Nach dem entpacken prüfen wir, ob alle Abhängigkeiten vorhanden sind und die Konfiguration der Installationsdateien aus:

./configure

Ist der Prozess erfolgreich beendet, kann man den Quelltext kompilieren und das Programm installieren:

make
sudo make install

Unsere Konfiguration wird später auf einigen Verzeichnissen bzw. Dateien aufbauen, welche wir nun anlegen:

sudo mkdir /usr/local/share/icecast/conf
sudo mkdir /usr/local/share/icecast/logs
sudo touch /usr/local/share/icecast/logs/access.log
sudo touch /usr/local/share/icecast/logs/error.log
sudo chown -R nobody:nogroup /usr/local/share/icecast/logs

Damit wäre dieser Schritt soweit abgeschlossen. Als nächstes folgt die Konfiguration.

Die Konfiguration von Icecast2

Die Konfigurationsdatei müssen wir manuell anlegen, und dazu haben wir vorhin schon den Ordner „conf“ erzeugt. Öffnet daran die Datei „config“ mit einem Editor eurer Wahl :)

sudo vim /usr/local/share/icecast/conf/config

Die Konfiguration basiert auf XML, und muss mit „<icecast>“ beginnen bzw. mit „</icecast>“ enden. Dazwischen packen wir die verschiedenen Konfigurationsblöcke, welche ich nach und nach erläutern werde. Eine genaue Erklärung der Einstellungsmöglichkeiten findet man in der Doku von Icecast2.

<limits>
    <clients>100</clients>
    <sources>2</sources>
    <threadpool>5/</threadpool>
    <queue-size>102400</queue-size>
    <client-timeout>30</client-timeout>
    <header-timeout>15</header-timeout>
    <source-timeout>10</source-timeout>
</limits>

Diese Einstellungen bestimmen die Softwarelimits des Icecasts. Laut der Doku reichen diese für kleine bis mittelgroße Streams und können ohne Erklärung einfach übernommen werden.

<authentication>
    <source-password>Source-PW</source-password>
    <relay-password>Relay-PW</relay-password>
    <admin-user>Adminuser</admin-user>
    <admin-password>Admin-Pw</admin-password>
</authentication>

In diesem Block setzt man die Logindaten. Einerseits für die Administration über den Webserver, andererseits zum Streamen. Diese Felder sollten unbedingt mit einem sicheren Passwort gefüllt werden.

<hostname>Icecast hosted by gehaxelt</hostname>
<listen-socket>
        <port>8000</port>
        <bind-address>IP</bind-address>
</listen-socket>

Hier könnt ihr den Hostnamen des Icecast Servers setzen. Zudem müsst ihr die IP-Adresse setzen und ggf. den Port anpassen, falls dieser euch nicht gefällt.

<fileserve>1</fileserve>
<paths>
    <basedir>/usr/local/share/icecast</basedir>
    <logdir>/logs</logdir>
    <pidfile>/icecast.pid</pidfile>
    <webroot>/web</webroot>
    <adminroot>/admin</adminroot>
    <alias source="/" dest="/status.xsl"/>
</paths>

Die erste Einstellung weist Icecast an, die Daten über den Webserver aufzubereiten (um diesen später ggf. zu administrieren). Ansonsten sollte man die Pfade so übernehmen können. Hinweis: Wir werden später Icecast in ein chroot stecken, sodass die weiteren Pfade relativ zum Base-Pfad sein müssen.

<logging>
    <accesslog>access.log</accesslog>
    <errorlog>error.log</errorlog>
    <loglevel>2</loglevel>
</logging>

Wir wollen natürlich – wie die NSA – alles protokollieren. Folgende Loglevel gibt es dabei:

• 1 – Error
• 2 – Warn
• 3 – Info
• 4 – Debug

Das Loglevel 2 ist meiner Meinung nach ausreichend.

<security>
    <chroot>1</chroot>
    <changeowner>
        <user>nobody</user>
        <group>nogroup</group>
    </changeowner>
</security>

Mit dem letzten Block versetzen wir Icecast nach dem Starten in ein chroot, und wechseln die Benutzerrechte auf nobody:nogroup.

Icecast2 Server starten bzw. stoppen

Um den Server zu stoppen, führt ihr einfach icecast mit Rootenrechten aus, und übergebt das entsprechende Config-File.

sudo icecast -c /usr/local/share/icecast/conf/config -b

Mit der Option „-b“ verabschiedet sich Icecast in den Hintergrund und läuft als Daemon weiter. Ihr solltet dann beim Aufrufen von [IP]:8000 auf die Willkommensseite von Icecast kommen. Ihr benötigt die Rootrechte, damit sich Icecast nach der Initialisierung ins chroot verschieben kann.

Um den Server wieder zu stoppen genügt ein killall:

sudo killall icecast

Fazit

Die Einrichtung von Icecast2 ist wirklich kein großes Problem, da die Konfiguration sehr übersichtlich ist, und ein vorkompiliertes Paket in den Paketquellen vorhanden ist. Das Streamen von Musik bzw. Podcasts über den eigenen Server ist nun kein Problem mehr.

~Sebastian

Was ist Mumble?

Mumble ist eine Alternative zu Teamspeak bzw. Skype. Man kann in verschiedenen Kanälen mit verschiedenen Personen sprechen. Es ist quelloffen, und läuft auf den meisten Betriebssystemen.

Die Voraussetzungen

Als Voraussetzung müssen wir ein wenig Software installieren, damit wir den Mumbleserver vom Source kompilieren können.

 sudo apt-get install git build-essential qt4-dev-tools libqt4-dev libspeex1 libspeex-dev \
                libboost-dev libasound2-dev libssl-dev g++ libspeechd-dev \
                libzeroc-ice-dev ice-slice libpulse-dev slice2cpp libcap-dev \
                libspeexdsp-dev libprotobuf-dev protobuf-compiler libogg-dev \
                libavahi-compat-libdnssd-dev libsndfile1-dev libg15daemon-client-dev libxi-dev qconf qt4-qmake

Nachdem die Installation der Software abgeschlossen ist, kann man ohne größere Probleme die nächsten Schritte abarbeiten.

Ich habe für den Mumble einen neuen Benutzer angelegt, damit man es nicht mit root-Rechten ausführt ;)

sudo adduser -m -s /bin/false mumble

Wir vergeben diesem Benutzer keine Bash, da er diese nicht benötigt. Für die späteren Logins werden wir die temporär setzen. Wir loggen uns nun also als mumble-User ein.

sudo su -s /bin/bash mumble

Mumbleserver kompilieren

Zum Kompilieren brauchen wir natürlich den Sourcecode, welchen wir uns über git herunterladen und in den neuen Ordner wechseln werden.

git clone git://github.com/mumble-voip/mumble.git mumble
cd mumble

Als nächstes müssen wir dann noch die Submodule einrichten:

git submodule init
git submodule update

Als nächstes rufen wir qmake gefolgt von make auf:

qmake -recursive main.pro CONFIG+=no-client
make

Der ganze Prozess dauert einige Minuten. Danach sollte sich die Binary im release Ordner befinden. Ich habe mir zur Übersicht einen symbolischen Link ins Homeverzeichnis gepackt.

 cd ~
 ln -s mumble/release/murmurd murmurd

Mumbleserver konfigurieren

Nachdem wir alles kompiliert haben, müssen wir den Server nur noch konfigurieren. Wir kopieren uns dazu die Beispielkonfiguration ins Homeverzeichnis.

 cp mumble/scrips/murmur.ini ~/

Diese könnt ihr dann mit einem Editor eurer Wahl bearbeiten. Folgende Einträge empfehle ich zu bearbeiten:

database=murmurdb.sqlite
dbus=session
ice="tcp -h 127.0.0.1 -p 6602"
icesecretread=[PW]
icesecretwrite=[PW]
logfile=murmur.log
pidfile=murmur.pid
port=64738
host=0.0.0.0
serverpassword=[SPW]
bandwith=72000
users=100
textmessagelength=5000
allowhtml=false
registerName=[ROOT-Channel Name]
uname=mumble

Als nächstes müssen wir das Superuserpasswort setzen. Dazu führen wir einmal murmurd mit dem entsprechenden Parameter auf:

./murmurd -supw [PW]

Mit dem Superuserpasswort könnt ihr euch später einloggen, um als Admin alle Einstellungen zu bearbeiten. murmurd sollte sich nach dieser Aktion wieder beenden.

Mumbleserver starten/stoppen

Wenn die Konfiguration nach den eigenen Wünschen abgeschlossen ist, dann können wir den Server nun starten.

 ./murmurd -ini ./murmur.ini

Ein Blick in die murmur.log bzw. ein Blick in die Prozessliste sollte dann zeigen, ob der Server erfolgreich läuft.

ps aux | grep murmur

Möchten wir den Server wieder beenden, dann lesen wir einfach die pid aus der entsprechenden Datei aus und übergeben dies als Argument für den kill Befehl.

 kill $(cat murmur.pid)

Mumbleserver Webinterface

Möchten wir zur besseren Konfiguration noch ein Webinterface installieren, so führen wir folgende Schritte aus.

Wir installieren das Mumble-Django Paket (Achtung: Apache2 wird mitinstalliert)

 sudo apt-get install mumble-django

Da ich den Apache nicht wirklich leiden kann, habe ich dessen Port in der /etc/apache2/ports.conf auf 88 statt 80 gesetzt. Dies ist nicht notwendig, falls kein anderer Webserver läuft.

Als nächstes führen wir eine Konfiguration des Paketes aus:

 sudo mumble-django-configure

Die Fragen könnt ihr so ähnlich beantworten:

1. 1
2. 1
3. Ice-secret aus der Konfiguration oben eingeben [PW]
4. 1

Ihr findet das Webinterface dann unter der angegeben Domain unter der folgenden URL:

 http://[DOMAIN]:[PORT]/mumble-django/

Ihr könnt euch dort mit dem Superuser anmelden, um zur Administration zu gelangen.

Fazit

Ich hoffe ihr könnt die Anleitung ohne weitere Probleme nachvollziehen, und habt viel Spaß beim Rummumblen ;)

~ Sebastian