Mich persönlich stört diese Neuerung etwas, denn die vorgeschlagene Personenliste erscheint mit einiger Verzögerung (zwischen 1-5 Sekunden) und drückt die eigentlichen Share-Apps nach unten weg, sodass ich immer versehentlich auf einen falschen Kontakt gedrückt habe. Außerdem kann jede App die Anordnung und Auswahl der angezeigten Kontakte selbst bestimmen, was mitunter zu Verwirrung geführt hatte.

Ein wenig Googeln brachte mich zu einem Stackoverflow-Thread mit der passenden Antwort. Diese funktioniert allerdings nur unter gerooteten Telefonen.

Man öffnet einen Dateimanager und legt in dem Ordner „/data/system/ifw/“ eine Datei mit dem Namen „disable_directshare.xml“ an. Der Inhalt der Datei muss folgendermaßen aussehen:

<rules>
  <service block="true" log="true">
    <intent-filter>
      <action name="android.service.chooser.ChooserTargetService" />
    </intent-filter>
  </service>
</rules>

Laut der Erklärung des Stackoverflow-Posters stellt dies einen neuen Eintrag in der Intents-Firewall dar, welche das Popup mit den Kontaktvorschlägen unterbindet.

~ Sebastian

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

Irgendwo auf Twitter oder einem anderen Medium habe ich ein Link zu dem Blogpost „[Tutorial] DS18S20 Temperatur Sensor an einem Raspberry Pi“ gefunden. Das hat mich so sehr fasziniert, dass ich das nachbauen wollte.

Dazu bestellte ich mir auf Amazon zunächst 10 solcher Sensoren mit entsprechend langem Kabel und Abdichtung: 10 x DS18B20 Digitale Temperaturfühler für ~15€. Dazu kamen noch ein paar 4.7k Ohm Widerstände. Nach ein paar Tagen war alles in meinem Briefkasten. Angeblich kann man sich von Maximintegrated ein kostenloses Sample zuschicken lassen. Allerdings kam bei mir bisher nichts an, vielleicht auch einfach Pech oder ein Fehler auf meiner Seite.

Aufbau

Für die Verkabelung des Sensors mit dem RaspberryPi bin ich den Schritten in dem oben genannten Blogpost gefolgt. Für mehr Informationen möchte ich dorthin verweisen.

Quelle: https://kopfkino.irosaurus.com/tutorial-ds18s20-temperatur-sensor-an-einem-raspberry-pi/

Wichtig ist scheinbar nur, dass man den GPIO-Pin 4 nutzt. Ich habe es selbst nicht mit anderen GPIO-Pins probiert. Wenn es bei euch mit anderen klappt, bitte einen kurzen Kommentar hinterlassen.

Konfiguration

Ich habe auf meinem RaspberryPi Archlinux mit einem halbwegs aktuellen Kernel am Laufen. Das führte dazu, dass die weiteren Schritte in dem oben genannten Blogpost nicht funktionierten. Nachdem ich ein wenig recherchiert habe, kam ich zu einer klein wenig modifizierten Lösung.

Zunächst muss man in die /boot/config.txt folgende Zeile anhängen:

dtoverlay=w1-gpio,gpiopin=4,pullup=on

Danach muss man noch Kernelmodule laden. Dies erledigt man am Besten direkt beim Booten, in dem man folgendes in die Datei /etc/modules einträgt:

w1-gpio pullup=1
w1_therm

Nach einem Neustart sollte der Sensor unter  „/sys/bus/w1/devices/<sensor-id>“ verfügbar sein. Mit folgendem Einzeiler kriegt man die aktuelle Temperatur heraus:

$> cat /sys/bus/w1/devices/28-041621eb50ff/w1_slave | grep -oP "t=(\d+)" | sed -e "s/t=//g"
21687

Automatisierung & Webseite

Ich wollte mir eine kleine grafische Ansicht über den Temperaturverlauf bauen. Dazu entschied ich mich, die Daten von zwei Sensoren (1x Indoor, 1x Outdoor) alle 30 Sekunden auszulesen und in eine SQLite3-Datenbank zu schreiben.

Dazu habe ich zwei Scripte unter „/opt/thermo/“ zu liegen. Das Erste kümmert sich nur um das Auslesen der Daten und heißt „data.sh“:

#!/bin/bash

outdoor=$(cat /sys/bus/w1/devices/28-041621eb50ff/w1_slave | grep -oP "t=(\d+)" | sed -e "s/t=//g")
indoor=$(cat /sys/bus/w1/devices/28-041621fadbff/w1_slave | grep -oP "t=(\d+)" | sed -e "s/t=//g")
seconds=$(TZ=Europe/Berlin date +"%s")

echo "$seconds,$indoor,$outdoor"

Die IDs müssen natürlich entsprechend angepasst werden.

Das zweite Script „insertdata.sh“ ruft „data.sh“ auf und schreibt die Daten in eine SQLite3-Datenbank.

#!/bin/bash
olddir=$(pwd)
cd /opt/thermo/
sqlite3 thermo.sqlite3 "insert into temperatures VALUES ($(./data.sh));"
cd "$olddir"

Da Archlinux mit Systemd kommt, können wir dessen Timer nutzen, um die Aufgabe alle 30 Sekunden abzufeuern. Dazu legen wir zunächst den Service unter „/etc/systemd/system/thermo.service“ an:

[Unit]
Description=Thermometer data collector

[Service]
Type=oneshot
ExecStart=/bin/bash /opt/thermo/insertdata.sh

Der Timer „/etc/systemd/system/thermo.timer“ führt diesen Service dann periodisch aus:

[Unit]
Description=Thermo data collector timer

[Timer]
Persistent=true
OnUnitActiveSec=30s
OnBootSec=30s

[Install]
WantedBy=timers.target

Diesen muss man mit einem kurzem Kommando aktivieren:

sudo systemctl enable thermo.timer

Zuletzt fehlte nur noch eine kleine Webseite, die die Daten aus der SQLite-Datenbank ausliest und anzeigt. Dazu habe ich einfach Apache + PHP installiert und folgende „index.php“ im DocumentRoot abgelegt.

<html>
<head>
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">

<!-- Optional theme -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap-theme.min.css" integrity="sha384-fLW2N01lMqjakBkx3l/M9EahuwpSfeNvV63J5ezn3uZzapT0u7EYsXMjQV+0En5r" crossorigin="anonymous">

<!-- Latest compiled and minified JavaScript -->
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js" integrity="sha384-0mSbJDEHialfmuBBQP6A4Qrprq5OVfW37PRR3j5ELqxss1yVqOtnepnHVP9aJ7xS" crossorigin="anonymous"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.0.0/Chart.js"></script>
</head>
<body class="container">
<?php
$db = new SQLite3('/opt/thermo/thermo.sqlite3');
$beginOfDay = strtotime("midnight", time());

$current = $db->query('SELECT * FROM temperatures order by timestamp desc limit 1');
$row = $current->fetchArray();

$currentDate = date("H:i:s - d.m.Y", $row['timestamp']);
$currentIndoor = round($row['indoor']/1000,3);
$currentOutdoor = round($row['outdoor']/1000,3);

$minmax = $db->query("SELECT MIN(indoor) as minIndoor, MIN(outdoor) as minOutdoor, MAX(indoor) as maxIndoor, MAX(outdoor) as maxOutdoor FROM temperatures where timestamp >= $beginOfDay order by timestamp desc");
$row = $minmax->fetchArray();

$minIndoor = round($row['minIndoor']/1000,3);
$maxIndoor = round($row['maxIndoor']/1000,3);
$minOutdoor = round($row['minOutdoor']/1000,3);
$maxOutdoor = round($row['maxOutdoor']/1000,3);

echo "<h1>Last measurement: $currentDate</h1>";
echo "<table class='table'><tr><th>Location</th><th>Current °C</th><th>Todays Min °C</th><th>Todays Max °C</th></tr>";
echo "<tr><td>Indoor</td><td>$currentIndoor</td><td>$minIndoor</td><td>$maxIndoor</td>";
echo "<tr><td>Outdoor</td><td>$currentOutdoor</td><td>$minOutdoor</td><td>$maxOutdoor</td>";
echo "</table>";

?>
<canvas id="myChart" width="300" height="100"></canvas>

<?php
$minmax = $db->query("SELECT * FROM temperatures where timestamp >= $beginOfDay order by timestamp asc");
$labels = array();
$indoor = array();
$outdoor = array();
$diff = array();
while($row = $minmax->fetchArray()) {
    $labels[] = date("H:i:s", $row['timestamp']);
    $indoor[] = round($row['indoor']/1000,3);
    $outdoor[] = round($row['outdoor']/1000,3);
    $diff[] = abs(round((abs($row['indoor']) - abs($row['outdoor']))/1000,3));
}
?>

<script>
var data = {
    labels: <?php echo json_encode($labels); ?>,
    datasets: [
        {
            label: "Indoor",
            fill: false,
            lineTension: 0.1,
            backgroundColor: "rgb(209,12,8)",
            borderColor: "rgb(209,12,8)",
            borderCapStyle: 'butt',
            borderDash: [],
            borderDashOffset: 0.0,
            borderJoinStyle: 'miter',
            pointBorderColor: "rgb(209,12,8)",
            pointBackgroundColor: "#fff",
            pointBorderWidth: 1,
            pointHoverRadius: 5,
            pointHoverBackgroundColor: "rgb(209,12,8)",
            pointHoverBorderColor: "rgba(220,220,220,1)",
            pointHoverBorderWidth: 2,
            pointRadius: 1,
            pointHitRadius: 10,
            data: <?php echo json_encode($indoor);?>,
        },
        {
            label: "Outdoor",
            fill: false,
            lineTension: 0.1,
            backgroundColor: "rgb(8,209,8)",
            borderColor: "rgb(8,209,8)",
            borderCapStyle: 'butt',
            borderDash: [],
            borderDashOffset: 0.0,
            borderJoinStyle: 'miter',
            pointBorderColor: "rgb(8,209,8)",
            pointBackgroundColor: "#fff",
            pointBorderWidth: 1,
            pointHoverRadius: 5,
            pointHoverBackgroundColor: "rgb(8,209,8)",
            pointHoverBorderColor: "rgba(220,220,220,1)",
            pointHoverBorderWidth: 2,
            pointRadius: 1,
            pointHitRadius: 10,
            data: <?php echo json_encode($outdoor);?>,
        },
        {
            label: "Difference",
            fill: false,
            lineTension: 0.1,
            backgroundColor: "rgba(75,192,192)",
            borderColor: "rgba(75,192,192)",
            borderCapStyle: 'butt',
            borderDash: [],
            borderDashOffset: 0.0,
            borderJoinStyle: 'miter',
            pointBorderColor: "rgba(75,192,192)",
            pointBackgroundColor: "#fff",
            pointBorderWidth: 1,
            pointHoverRadius: 5,
            pointHoverBackgroundColor: "rgba(75,192,192)",
            pointHoverBorderColor: "rgba(220,220,220,1)",
            pointHoverBorderWidth: 2,
            pointRadius: 1,
            pointHitRadius: 10,
            data: <?php echo json_encode($diff);?>,
        }
    ]
};

var ctx = document.getElementById("myChart");
var myLineChart = new Chart(ctx, {
    type: 'line',
    data: data,
});
</script>
</body>
</html>

~ Sebastian

Ich nutze das Plugin „Vicious“ für den Batteriestatus in Awesome. Eine beispielhafte Implementierung für das Battery-Widget findet man in der README, allerdings bei mir im Textmodus:

batwidget = wibox.widget.textbox()
vicious.register(batwidget, vicious.widgets.bat, "⚡: $2%/$3", 30, "BAT0")

Der 3. Parameter kann netterweise eine Funktion sein, sodass man einfach den Batteriestatus prüfen und entsprechend eine Meldung ausgeben kann:

vicious.register(batwidget, vicious.widgets.bat, function(widget, args) 
 if args[2] <= 15 then
 naughty.notify({
 title="BATTERY!!",
 text="Battery left: "..args[2].."%",
 bg="#ff0000",
 fg="#000",
 timeout=5,
 border_width=5,
 font="Arial 25" 
 })
 end
 return "⚡: "..args[2].."%/".. args[3]
 end, 30, "BAT0")

In meinem Fall wird die Meldung angezeigt, wenn weniger als 15% Akku verbleiben. Das sieht dann so aus (100% nur, da es ein Test ist):

Damit sollten sich die unbemerkten Abschaltungen meines Laptops in Zukunft drastisch reduzieren.

~ Sebastian

Was ist Iodine?

Iodine ist ein IP-over-DNS Tunnel. Das bedeutet, dass man seinen normalen IP-Traffic in viele kleine Stückchen zerhackt und dann über das DNS-Protocol verschickt. Ein Server dient dabei als Proxy. Viele Hotspots blockieren TCP und UDP Traffic, um die Zahlung einer Gebühr zu fordern. Allerdings besteht diese Beschränkung oft nicht für den DNS-Verkehr (Port 53 UDP), sodass Hotspots ‚umgangen‘ werden können. ‚Umgangen‘ ist hier jedoch die falsche Bezeichnung, denn das Relayen des DNS-Traffics könnte genauso deaktiviert bzw. nur für zahlende Kunden konfiguriert werden.

Voraussetzungen

Damit das ganze System korrekt funktioniert, benötigt man folgende Voraussetzungen:

• (virtuellen) Server:
  • Rootrechte
  • Iptables
  • Port 53 udp frei
• Domain-Registrar, bei dem man eigene NS-Einträge setzen kann
• Für Nutzung auf dem Handy:
  • Rootrechte
  • AndIodine
  • Proxydroid
• Für Nutzung auf dem PC:
  • Rootrechte
  • Tsocks

Folgende Annahmen gelten für diesen Blogpost:

• Euer Server hat die IP: 127.0.0.1
• Eure Domain lautet: domain.tld
• Eine Subdomain lautet: iodns.domain.tld
• Die Subdomain zeigt auf den Server: 127.0.0.1
• Iodine-Subdomain ist: iod.domain.tld

Einrichtung des DNS

Damit Iodine funktioniert, muss es einen Nameserver emulieren. Dazu müsst ihr euch bei eurem DNS-Registrar anmelden und dort einige neue Einträge anlegen:

• A-Record: iodns.domain.tld -> 127.0.0.1
• NS-Record: iod.domain.tld -> iodns.domain.tld

Nun werden alle DNS-Anfragen, welche auf iod.domain.tld enden, an den Server geschickt, auf dem wir später Iodine laufen lassen werden.

Einrichtung von Iodine

Man loggt sich auf seinem Server ein und lädt den Iodine-Sourcecode herunter:

curl http://code.kryo.se/iodine/iodine-0.7.0.tar.gz -o /tmp/iodine.tgz

Man entpackt das Archiv:

cd /tmp/
tar xfv iodine.tgz

Zuletzt dann noch kompilieren und installieren:

cd /tmp/iodine-*/
make
sudo make install

Ihr solltet daraufhin zwei Binaries im Ordner ‚/usr/local/sbin/‘ finden:

ls /usr/local/sbin/
iodine iodined

Die Binary mit dem ‚d‘ hinten ist der Daemon, welchen wir auf dem Server laufen lassen werden. Am Besten legt man dazu einen neuen Nutzer an:

sudo useradd -m -s /bin/nologin iodine

Danach führt man folgenden Befehl aus:

sudo /usr/local/sbin/iodined -f -c -u iodine -P geheimesPW 192.168.99.1 iod.domain.tld

Die Parameter erklärt:

• -f: Behält das Programm im Vordergrund. Sollte nach einem Testlauf deaktiviert werden bzw. muss in Kombination mit Daemontools genutzt werden.
• -c: Verhindert das IP-Checking, welches ansonten zu Verbindungsproblemen führen kann.
• -u: Ändert den Nutzer, mit dem der Daemon läuft
• -P: Setzt ein Passwort
• 192.168.99.1 ist das Subnetz für den Tunnel.

Als nächstes muss man noch einige Einstellungen an der Firewall ändern:

• Port 53 UDP muss geöffnet werden, damit Pakete zu Iodine durchkommen
• Port 8080 TCP muss auf dem virtuellen Interface von Iodine (dns0/192.168.99.1) geöffnet werden, um den Socks-Server laufen zu lassen.

Im nächsten Schritt richten wir noch einen simplen Socks-Server ein, welcher auf dem dns0-Interface lauschen wird. Alle Clients werden später ihren Traffic über den Socks-Server tunneln.

An dieser Stelle sei erwähnt, dass man mittels IP-Forwarding den gesamten Traffic über Iodine tunneln lassen könnte, jedoch wollte ich in meinem Anwendungsszenario nur bestimmte Programme über den Tunnel telefonieren lassen.

Wir werden das kleine Tool Ssocks nutzen. Man lädt die Quellen herunter:

curl http://netassist.dl.sourceforge.net/project/ssocks/ssocks-0.0.14.tar.gz -o /tmp/ssocks.tgz

Danach werden diese entpackt und gebaut:

cd /tmp/
tar xfv ssocks.tgz
cd ssocks-*
./configure
make
sudo make install

Man legt wieder einen neuen User an:

sudo useradd -m -s /bin/nologin ssocks

Danach kann man den Socks-Proxy ganz einfach starten:

sudo -u "ssocks" /usr/local/bin/ssocksd -b 192.168.99.1 --port 8080

Nun sollte die Konfiguration des Servers abgeschlossen sein.

Nutzung auf dem Handy

Um Iodine auf dem Handy nutzen zu können, muss dieses gerootet sein. Danach installiert man sich aus dem F-Droid Store die App AndIodine.

In der App legt man ein neues Profil an und setzt folgende Optionen:

• Tunnel Topdomain: iod.domain.tld
• Password: geheimesPw
• Lazy mode: Häkchen
• Raw mode: Häkchen
• Default route: Kein Häkchen

Die restlichen Einstellungen können so gelassen werden. Hilfestellung bekommt man über die Fragezeichen neben den Optionsfeldern.

Dann benötigt man noch eine App aus dem Playstore, nämlich ‚Proxydroid‚. [appbox googleplay org.proxydroid ]

In dieser App legt man folgende Optionen fest:

• Host: 192.168.99.1
• Port: 8080
• Type: SOCKS5
• Global Proxy: Häkchen

Um über Iodine ins Internet zu kommen, wird folgender Algorithmus angewendet:

1. Verbindung zum Hotspot herstellen
2. AndIodine öffnen und eine Verbindung zum Iodine-Server herstellen
3. Proxydroid starten und Proxy aktivieren
4. Fertig

Danach sollte man über den Proxy surfen können.

Nutzung mit dem PC

Zunächst installiert man sich, ähnlich wie oben aufgeführt, Iodine. Danach kann man sich folgendermaßen zum Server verbinden:

/usr/local/sbin/iodine -f 127.0.0.1 iod.domain.tld

Die Parameter erklärt:

• -f: Im Vordergrund bleiben
• 127.0.0.1: IP eures (Name)servers
• iod.domain.tld: Iodine-Subdomain

Danach solltet ihr den Server pingen können:

ping 192.168.99.1

Der letzte Schritt besteht darin, einen kleinen Socks-Proxy zu installieren bzw. ein Tool, welches den Traffic einer Applikation transparent durch unseren Iodine-Socks-Proxy schiebt. Ich nutze dafür ‚tsocks‘. Unter Archlinux gibt es dazu ein Paket:

sudo pacman -S tsocks

Danach kopiert man sich die Beispielkonfiguration nach /etc/:

cp /usr/share/tsocks/tsocks.conf.simple.example /etc/tsocks.conf

Darin ändert man die entsprechenden Einträge folgendermaßen ab:

# We can access 192.168.0.* directly
local = 192.168.99.0/255.255.255.0

# Otherwise we use the server
server = 192.168.99.1
server_port = 8080
server_type = 5

Nun kann man einem Programm einfach ‚tsocks‘ voranstellen. Zum Vergleich:

$> curl ip.gehaxelt.in
91.9.YY.XX
$> tsocks curl ip.gehaxelt.in
87.106.YY.XX

Fertig!

Geschwindigkeit

Je nachdem welche Fragmentsize der DNS-Relay durchlässt, schwankt die Übertragungsgeschwindigkeit enorm. Am Besten ist natürlich der ‚Raw mode‘, denn dann können die Pakete direkt an unseren Nameserver geschickt werden. Zusätzlich fällt ins Gewicht, dass DNS auf UDP basiert und dadurch viele Vorteile gegenüber TCP fehlen. Beispielsweise die Retransmission, wenn ein Paket im Internet verloren geht.

Meine Erfahrungen zeigen, dass die Geschwindigkeit von 1 Megabyte/10 Minuten (13Kbit/s ~ 2KB/s) bis hin zu 600KB/s schwankt. Es ist also weniger zum richtigen Surfen, als zum ‚Notfall‘-Emailabrufen geeignet.

~ Sebastian

in diesem Blogpost möchte ich beschreiben wie man mit Hilfe einer udev-Regel und Systemd eine mit luks verschlüsselte SD-Karte automatisch mounten lassen kann.

Vorwort: SD-Karte verschlüsseln

Damit man die SD-Karte automatisch entschlüsseln lassen kann, bietet es sich an, diese mit einem Keyfile zu verschlüsseln. Dazu erstellt man zunächst ein Keyfile:

sudo dd bs=512 count=4 if=/dev/urandom of=/etc/sdkey iflag=fullblock

Damit nicht jeder diesen Schlüssel lesen kann, verpasst man ihm noch die korrekten Rechte und einen Änderungsschutz:

sudo chmown root:root /etc/sdkey
sudo chmod 500 /etc/sdkey
sudo chattr +i /etc/sdkey

Danach kann man auch schon mit cryptsetup die SD-Karte verschlüsseln:

sudo cryptsetup luksFormat /dev/mmcblk0p1 /etc/sdkey

• /dev/mmcblk0p1 ist die zu verschlüsselnde Partition auf der SD-Karte
• /etc/sdkey ist das Keyfile, dass zur Verschlüsselung genutzt wird

Zuletzt öffnet man die SD-Karte und erstellt ein Dateisystem:

sudo cryptsetup --key-file=/etc/sdkey luksOpen /dev/mmcblk0p1 sdcard
sudo mkfs.ext4 /dev/mapper/sdcard

Fertig.

Automatische Entschlüsselung und Einbindung

Zum automatischen Entschlüsseln und Mounten der SD-Karte müssen wir eine neue udev-Regel und ein passendes Systemd Unitfile schreiben.

Systemd Unitfile

Wir beginnen mit dem Systemd Unitfile, da dieses relativ straight forward ist. Man legt eine neue Datei an: ‚/etc/systemd/system/sdcardencrypt.service‘. Der Inhalt kann so aussehen:

[Unit]
Description=Automount encrypted sdcard

[Service]
Type=oneshot
ExecStart=/usr/bin/cryptsetup --key-file=/etc/sdkey luksOpen /dev/sdcard sdcard
ExecStart=/usr/bin/mount /dev/mapper/sdcard /sdcard

Möchte man in dem Unitfile mehere ‚ExecStart‘-Kommandos ausführen, so ist ‚Type=oneshot‘ zu setzen.

Das erste Kommando ist bereits von oben bekannt und öffnet den luks-Container. Neu ist hier, dass als Device ‚/dev/sdcard‘ statt ‚/dev/mmcblk0p1‘ angegeben wird. Das erklärt sich aber später mit unserer udev-Regel.

Der zweite Befehl mountet den luks-Container in ‚/sdcard‘. Der Mountpoint muss einmalig davor erstellt werden und/oder geändert werden.

Damit Systemd das neue Unitfile korrekt ausführt, müssen wir einen kurzen Reload durchführen:

sudo systemctl daemon-reload

Udev-Regel

Als nächstes machen wir uns an die udev-Regel, welche den Symlink zu ‚/dev/sdcard‘ erstellt und das unser Unitfile aufruft. Dazu erstellen wir eine Datei in ‚/etc/udev/rules.d/‘ mit dem Namen ’10-sdcard.rules‘ und folgendem Inhalt:

ACTION=="add", KERNEL=="mmcblk0p1", SUBSYSTEM=="block", ATTR{size}=="124702720", ATTR{start}=="32768", SYMLINK+="sdcard", ENV{SYSTEMD_WANTS}="sdcardencrypt.service"

Hier passieren mehrere Dinge:

• ACTION: Nur wenn das neue Gerät eingesteckt wird, soll die Regel ausgeführt werden
• KERNEL, SUBSYSTEM, ATTR: Verundete Kriterien; Nur wenn alle matchen, wird die Regel ausgeführt
• SYMLINK: Erzeuge ein Symlink von der gematchten Partition ‚/dev/mmcblk0p1‘ zu ‚/dev/sdcard‘
• ENV: Führe danach das ’sdcardencrypt.service‘ Unitfile aus.

Das einzige, was ihr an der Regel ändern müsst, sind die Werte hinter KERNEL, ATTR{size}, ATTR{start}. Da wir hier von einer SD-Karte reden, wird SUBSYSTEM wahrscheinlich den Wert beibehalten. Alle anderen Werte nutze ich, um meine verschlüsselte SD-Karte (eindeutig) zu identifizieren.

An die entsprechenden Attribute gelangt man die SD-Karte einsteckt und danach das folgende Kommando ausführt:

udevadm info -a -p (udevadm info -q path -n /dev/mmcblk0p1)

Dabei ersetzt man ‚/dev/mmcblk0p1‘ mit der entsprechenden Partition der SD-Karte. Die Ausgabe kann so ähnlich aussehen:

udevadm info -a -p (udevadm info -q path -n /dev/mmcblk0p1)

Udevadm info starts with the device specified by the devpath and then
walks up the chain of parent devices. It prints for every device
found, all possible attributes in the udev rules key format.
A rule to match, can be composed by the attributes of the device
and the attributes from one single parent device.

 looking at device '/devices/pci0000:00/0000:00:1c.0/0000:02:00.1/mmc_host/mmc0/mmc0:aaaa/block/mmcblk0/mmcblk0p1':
 KERNEL=="mmcblk0p1"
 SUBSYSTEM=="block"
 DRIVER==""
 ATTR{alignment_offset}=="0"
 ATTR{discard_alignment}=="8388608"
 ATTR{inflight}==" 0 0"
 ATTR{partition}=="1"
 ATTR{ro}=="0"
 ATTR{size}=="124702720"
 ATTR{start}=="32768"
 ATTR{stat}==" 38 0 1099 136 0 0 0 0 0 56 136"

 looking at parent device '/devices/pci0000:00/0000:00:1c.0/0000:02:00.1/mmc_host/mmc0/mmc0:aaaa/block/mmcblk0':
 KERNELS=="mmcblk0"
 SUBSYSTEMS=="block"
 DRIVERS==""
 ATTRS{alignment_offset}=="0"
 ATTRS{capability}=="10"
 ATTRS{discard_alignment}=="0"
 ATTRS{ext_range}=="8"
 ATTRS{force_ro}=="0"
 ATTRS{inflight}==" 0 0"
 ATTRS{range}=="8"
 ATTRS{removable}=="0"
 ATTRS{ro}=="0"
 ATTRS{size}=="124735488"
 ATTRS{stat}==" 52 0 2155 206 0 0 0 0 0 96 206"

 looking at parent device '/devices/pci0000:00/0000:00:1c.0/0000:02:00.1/mmc_host/mmc0/mmc0:aaaa':
 KERNELS=="mmc0:aaaa"
 SUBSYSTEMS=="mmc"
 DRIVERS=="mmcblk"
 ATTRS{cid}=="035344534c36344780295762d200f800"
 ATTRS{csd}=="400e00325b590001dbd37f800a404000"
 ATTRS{date}=="08/2015"
 ATTRS{erase_size}=="512"
 ATTRS{fwrev}=="0x0"
 ATTRS{hwrev}=="0x8"
 ATTRS{manfid}=="0x000003"
 ATTRS{name}=="SL64G"
 ATTRS{oemid}=="0x5344"
 ATTRS{preferred_erase_size}=="25165824"
 ATTRS{scr}=="0245800300000000"
 ATTRS{serial}=="0x295762d2"
 ATTRS{type}=="SD"

 looking at parent device '/devices/pci0000:00/0000:00:1c.0/0000:02:00.1/mmc_host/mmc0':
 KERNELS=="mmc0"
 SUBSYSTEMS=="mmc_host"
 DRIVERS==""

 looking at parent device '/devices/pci0000:00/0000:00:1c.0/0000:02:00.1':
 KERNELS=="0000:02:00.1"
 SUBSYSTEMS=="pci"
 DRIVERS=="sdhci-pci"
 ATTRS{broken_parity_status}=="0"
 ATTRS{class}=="0x080501"
 ATTRS{consistent_dma_mask_bits}=="32"
 ATTRS{d3cold_allowed}=="1"
 ATTRS{device}=="0x16bc"
 ATTRS{dma_mask_bits}=="64"
 ATTRS{driver_override}=="(null)"
 ATTRS{enable}=="1"
 ATTRS{irq}=="17"
 ATTRS{local_cpulist}=="0-3"
 ATTRS{local_cpus}=="0f"
 ATTRS{msi_bus}=="1"
 ATTRS{numa_node}=="-1"
 ATTRS{subsystem_device}=="0x0504"
 ATTRS{subsystem_vendor}=="0x1025"
 ATTRS{vendor}=="0x14e4"

 looking at parent device '/devices/pci0000:00/0000:00:1c.0':
 KERNELS=="0000:00:1c.0"
 SUBSYSTEMS=="pci"
 DRIVERS=="pcieport"
 ATTRS{broken_parity_status}=="0"
 ATTRS{class}=="0x060400"
 ATTRS{consistent_dma_mask_bits}=="32"
 ATTRS{d3cold_allowed}=="0"
 ATTRS{device}=="0x1c10"
 ATTRS{dma_mask_bits}=="32"
 ATTRS{driver_override}=="(null)"
 ATTRS{enable}=="1"
 ATTRS{irq}=="17"
 ATTRS{local_cpulist}=="0-3"
 ATTRS{local_cpus}=="0f"
 ATTRS{msi_bus}=="1"
 ATTRS{numa_node}=="-1"
 ATTRS{subsystem_device}=="0x0504"
 ATTRS{subsystem_vendor}=="0x1025"
 ATTRS{vendor}=="0x8086"

 looking at parent device '/devices/pci0000:00':
 KERNELS=="pci0000:00"
 SUBSYSTEMS==""
 DRIVERS==""

Am Besten nimmt man die Attribute von weiter oben. Es stellt allerdings auch kein Problem dar, wenn man Attribute nutzt, die weiter unten stehen, nur sind diese etwas genereller und könnten gegebenenfalls auf andere SD-Karten matchen. Allerdings darf man nur Attribute von einem ‚Parent‘ des Devices nutzen. Für bessere Robustheit könnte man noch zusätzliche folgende Attribute einführen:

• ATTRS{manfid}==“0x000003″
• ATTRS{name}==“SL64G“
• ATTRS{oemid}==“0x5344″
• ATTRS{serial}==“0x295762d2″
• ATTRS{type}==“SD“

Zuletzte sollte man noch die Regeln neu einlesen. Das klappt einfach mit einem:

sudo udevadm trigger

Fazit

Es braucht nicht viel Bastelei, um eine verschlüsselte SD-Karte automatisch einzubinden. Möglicherweise möchte man sich aber noch Gedanken darüber machen, dass der Mountpoint bzw. Luks-Container geschlossen wird, wenn die SD-Karte ausgehängt wird. Da ich das nicht häufig/wirklich benötige, ist dies dem interessierten Leser überlassen.

~ Sebastian

in diesem Blogpost möchte ich euch das Tool „Pandoc“ vorstellen. Ich habe es durch Zufall gefunden und werde es in Zukunft wahrscheinlich öfters nutzen. Mit dem Programm kann man Konvertierungen zwischen verschiedenen Dateiformaten durchführen.

Eingabeformate

Folgende Formate können als Eingabe für Pandoc genutzt werden:

• docbook
• docx
• epub
• haddock
• html
• json
• latex
• markdown
• markdown_github
• markdown_mmd
• markdown_phpextra
• markdown_strict
• mediawiki
• native
• opml
• org
• rst
• t2t
• textile
• twiki

Ausgabeformate

In folgende Formate kann umgewandelt werden:

• asciidoc
• beamer
• context
• docbook
• docx
• dokuwiki
• dzslides
• epub
• epub3
• fb2
• haddock
• html
• html5
• icml
• json
• latex
• man
• markdown
• markdown_github
• markdown_mmd
• markdown_phpextra
• markdown_strict
• mediawiki
• native
• odt
• opendocument
• opml
• org
• pdf [use latex or beamer and -o FILENAME.pdf]
• plain
• revealjs
• rst
• rtf
• s5
• slideous
• slidy
• texinfo
• textile

Nutzung

Die Nutzung ist relativ einfach. Es gibt eigentlich nur drei Parameter, die man sich merken muss.

• -f bzw. –from FORMAT : Eingabeformat angeben
• -t bzw. –to FORMAT : Ausgabeformat angeben
• -o bzw. –output FILE : Für Ausgabeformate, die nicht auf der Konsole ausgegeben werden können

Der Aufruf erfolgt zum Beispiel mit

pandoc -f markdown -t pdf -o ausgabe.pdf eingabe.md

Weitere nützliche Beispiele findet man auf der Projektwebseite: http://pandoc.org/demos.html.

Man dann auch direkt online den Funktionsumfang testen: http://pandoc.org/try/

Natürlich gibt es das Programm als gleichnamiges Paket in den meisten Paketquellen.

~ Sebastian

heute habe ich nach einer Möglichkeit gesucht, herauszufinden, welche Pakete welche Abhängigkeiten haben. Am Ende meiner Recherche wurden mir schöne bunte Graphen erzeugt. Dabei benötigt man dazu eigentlich nur zwei kleine Programme: Pactree und Graphviz.

Pactree

Pactree beschreibt sich selbst als „A simple dependency tree viewer.“ für Arch Linux. Man kann sich zum Beispiel ausgeben lassen, welche Abhängigkeiten das Paket „glibc“ hat:

> pactree glibc
glibc
├─linux-api-headers
├─tzdata
└─filesystem
 └─iana-etc

Die folgenden Switches werden wir gleich verwenden, um aus diesen Informationen schöne Grafiken zu bauen:

-c, --color          colorize output
-g, --graph          generate output for graphviz's dot

Die Abhängigkeiten von Oben ergeben folgende „dot“-Beschreibung:

> pactree -c -g glibc
digraph G { START [color=red, style=filled];
node [style=filled, color=green];
 "START" -> "glibc";
"glibc" -> "linux-api-headers" [color=chocolate4];
"glibc" -> "tzdata" [color=chocolate4];
"glibc" -> "filesystem" [color=chocolate4];
"filesystem" -> "iana-etc" [color=chocolate4];
}

Interessant kann auch die Verwendung des Switches „-r“ sein.

 -r, --reverse        list packages that depend on the named package

Graphviz

Graphviz ist eine kleine Toolsammlung, welche genutzt werden kann, um schöne Graphen zu erzeugen. Zum Beispiel aus dem o.g. Code.

Um die Umwandlung durchzuführen, führt man folgendes Kommando aus:

dot -Tgif deps.graph -o deps.gif

Wobei „deps.graph“ für den Eingabegraphen in dot-Notation und deps.gif für die Ausgabe im GIF-Format steht. Eine Liste mit weiteren Formaten gibt es natürlich auch. Man muss nur entsprechend „-Tgif“ durch „-TFORMAT“ ersetzen.

Die Aufrufe lassen sich natürlich verketten:

pactree -c -g glibc | dot -Tgif -o /tmp/glibc.gif

Das Ergebnis sieht dann so aus:

Oder etwas komplexer, wie z.B. für das „Gimp“-Programm.

~ Sebastian

bei Pecha-Kucha Vorträgen handelt es sich um einen Vortragsstil bei dem der Vortragende genau 20 Folien zu je 20 Sekunden vorstellen darf. Um diese Vorträge gut zu üben, kann man das Tool ‚Impressive‘ nutzen.

PDF vorbereiten

Erstellt man seine Präsentation mit Latex und dem Beamer-Package (sehr zu empfehlen!!), dann muss man in seiner Latex-Datei vor dem Beginn des Dokuments die PDF-Version 1.4 einstellen, da die neue Version mit Impressive leider nicht kompatibel ist:

\RequirePackage{pdf14}
\documentclass[]{beamer}
...

Ansonsten erkennt Impressive keine Folien und beendet sich mit der Fehlermeldung:

PDF renderer: Xpdf/Poppler
WARNING: The input file `Folien.pdf' could not be analyzed.
The presentation doesn't have any pages, quitting.

Impressive nutzen

Impressive kann man sich unter Arch-Linux aus dem gleichnamigen Paket installieren:

sudo pacman -S impressive

Danach startet man Impressive mit der Option „-a 20“, um das automatische Umschalten der Folien nach 20 Sekunden zu aktivieren:

impressive -a 20 Folien.pdf

Die Folien werden sofort angezeigt und der Countdown gestartet.

~ Sebastian

ich hatte letztens eine kleine Idee, für die ich eine VM mit Android benötige. So kann man einfach Apps installieren und ausprobieren, ohne Gefahr zu laufen, dass etwas auf dem eigenen Telefon mitgesammelt wird.

In diesem Blogpost geht es also um die Einrichtung der Android-VM auf einem PC und einigen Tipps/Tricks zur einfacheren Verwendung.

VM aufsetzen

Zu unserem Vorteil haben einige Entwickler einen Port von Android für die x86-Architektur geschrieben, welche wir im Folgenden nutzen werden. Daher lädt man sich zunächst die letzte Version herunter:

https://code.google.com/p/android-x86/downloads/

Ich empfehle das Iso der 4.3er Version. (Aktuellste Version zum Zeitpunkt des Schreibens)

Während das Iso heruntergeladen wird, kann man bereits VirtualBox starten und dort eine neue virtuelle Maschine anlegen.

Bei der Frage nach dem Betriebssystem wählt man „Linux“ bzw. „Linux 2/3 (32 bit)“ aus. Als Namen kann man zum Beispiel „Android“ wählen. Auf jeden Fall wird der Name später noch benötigt, sodass man sich diesen merken sollte.

An Arbeitsspeicher und Festplattenspeicher sollte nicht gespart werden:

• RAM: 1 GB
• Festplattenspeicher: Mindestens 6 GB
• Netzwerk: NAT

Ist die VM erstellt und der Download fertig, so kann man mit der Installation fortfahren.

Dazu startet man die VM und legt das ISO in das virtuelle CD-Laufwerk ein. Auf dem Startbildschirm wählt man den untersten Eintrag „Install to disk“ aus.

Danach sollte eine UI zum Verwalten der Datenträger erscheinen. Normalerweise existiert hier nur ein Eintrag, welchen man mit „New“ und „ext3“ formatiert. Des Weiteren muss noch die Schaltfläche „Bootable“ angewählt werden, damit Android später auch starten kann.

Die Änderungen bestätigt man mit der Auswahl von „Write“ und einem Druck auf die Entertaste.

Als nächstes kommt die Nachfrage, ob das Dateisystem als „read/write“ geschrieben werden soll. Ich habe diese Frage mit „Ja“ beantwort – die Entscheidung ist aber jedem selbst überlassen.

Die Installation des Betriebssystems dauert ungefähr eine Minute und danach kann das System neugestartet werden.

Nun sollte man auch den vertrauten Einrichtungsassistenten sehen und das Androidsystem ganz gewohnt nutzen können.

VM aufwecken

Das Androidsystem geht nach einer Weile der Nichtnutzung in den Standby, wie man es vom Handy kennt. Um das System wieder aufzuwecken, muss man laut der Dokumentation einer der folgenden Tasten mindestens 1 Sekunde lang drücken:

• ESC
• Linke/Rechte Maustaste
• Hoch/Runter-Taste

Bei mir klappte das allerdings nicht wirklich zuverlässig (vielleicht liegt es auch an mir). Daher hab ich in den Einstellungen von Android den Standby abgeschaltet.

Fehlender Mauszeiger

Falls man in der Android-VM den Mauszeiger nicht sehen kann, so liegt das höchstwahrscheinlich an der „Mauszeigerintegration“ von Virtualbox. Schaltet man diese aus, so wird die Maus in der VM gefangen, und kann normal genutzt werden.

Das klappt bei der laufenden VM über „Maschine->Mauszeigerintegration deaktivieren“.

Ist der Mauszeiger in der VM gefangen, so kann man diesen mittels einem Druck auf die rechte Strg-Taste befreien.

ADB Portforward

Um über ADB mit dem System zu interagieren muss man eine Portforwarding-Regel anlegen. Dazu fährt man die VM zunächst herunter. Dann führt man folgenden Befehl aus:

VBoxManage modifyvm "Android" --natpf1 adb,tcp,*,5555,*,5555

Wobei „Android“ der Name der virtuellen Maschine ist.

Danach kann man auf seinem Hostsystem adb nutzen, um sich zu verbinden:

adb connect localhost

Fazit

Meiner Meinung nach ist das eine coole Sache, um zum Beispiel Apps auf böses Verhalten zu untersuchen.

~ Sebastian