# FAQ Tips > Hier Suchen und Finden, Links, Tutorials >  Loop-AES unter Linux (Partition, Container, CD/DVD und Windows)

## DaGrrr

*Howto Version: v0.1.6*

*AES Verschlüsselung unter Linux / Windows*


Ich möchte hier aufzeigen, wie man eine AES Verschlüsselung unter Linux 2.6.x und Windows einrichtet. Viele User möchten gerne ihre verschlüsselten Daten sowohl unter Linux als auch unter Windows nutzen, daher dieser Artikel. 

1) loop-aes installation und konfiguration für verschlüsselte Partitionen und Container 
2) zusätzliche Algorithmen (Serpant, Twofish, Blowfish) 
3) verschlüsselte Datensicherung auf CD/DVD 
4) Swap-Partition mit loop-aes verschlüsseln 
5) loop-aes und ein monolitischer Kernel 
6) AES mit CrossCrypt für Windows 
7) loop-aes installationsscript von *Thorsten Hirsch* 
8) Download als PDF

01.02.2006 Auf Wunsch von Usern auch als PDF erhältlich
18.10.2005 Swap Howto: Fehlerbehebung
28.07.2005 Howto Version v0.1.6
28.07.2005 loop-aes und monolitischer Kernel
27.07.2005 Howto Version v0.1.5
27.07.2005 Bitlängen möglichkeiten für zusätzliche Algorithmen hinzugefügt
27.07.2005 Ergänzt: Verschlüsseln der Swap-Partition mit loop-aes
17.07.2005 Erstellung des kompletten Howtos (Version 0.1.0)

*Fragen zum Thema bitte nur im Forum stellen, ich gebe keinen Support außerhalb des Forums!*




> Sollte sich irgendwo der Fehlerteufel eingeschlichen haben, dann schickt mir eine PN (Private Nachricht) oder eine E-Mail an holgi [at] linux-technik [dot] de und wer mir lieber mit gnupg schreiben möchte: Mein PGP-Key: Download 
> 
> Fingerprint:
> 4DFA 402D 96E1 0F46 5232 68E3 9A3D FDE5 0527 CA77

----------


## DaGrrr

*Linux:*


*Anmerkung:*
Bevor wir mit der Einrichtung von loop-aes beginnen ist es wichtig, das wir uns einen eigenen Kernel kompilieren. Der Grund liegt darin, dass loop-aes einen eigenen loopback-support und eigenen AES-Code mitbringt.
Bei vielen Distributionen ist der loopback-support und die Kernel eigenen Cipher im Kernel aktiviert und als Modul verfügbar, womit loop-aes aber nicht klar kommt.
Daher ist es wichtig, diese Dinge im eigenen Kernel zu deaktivieren und den Kernel neu kompilieren.

Wie man einen Kernel kompiliert (Version 2.6.x) 
Kernel kompilieren (Allgemein) 

Als erstes benötigen wir 2 Files die wir herunterladen müssen. 

Loop-aes: http://loop-aes.sourceforge.net/loop-AES/

util-linux: ftp://ftp.kernel.org/pub/linux/utils/util-linux/

Als nächstes entpacken wir die Dateien: 



```
tar xjvf loop-AES-VERSION.tar.bz2.tar
tar xjvf util-linux-VERSION.tar.bz2.tar
```

Beim entpacken werden jeweils 2 Ordner angelegt. 

Als nächsten Schritt kopieren wir aus dem Ordner loop-AES-VERSION die Datei util-linux-version.diff ins zuvor util-linux entpackte Verzeichnis. 


Mit dem Befehl: 



```
patch -p1 < util-linux-version.diff
```

patchen wir util-linux (mount, umount, losetup) 


Sollte es beim patchen Fehler geben, so haben wir die falsche Version von util-linux heruntergeladen. Es ist wichtig, das der Patch zu unserer Version passt. 


Danach führen wir folgende Befehle im util-linux Verzeichnis aus: 



```
./configure
make ADD_RAW=no
cd mount
install -m 4755 -o root mount umount /bin
install -m 755 losetup /sbin
```

Damit werden die Programme mount und umount ins Verzeichnis /bin und losetup nach /sbin kopiert.

Danach wechseln wir in unser loop-aes-v2.x Verzeichnis und führen 


```
make
```

aus. 


Ist die kompilierung erfolgreich verlaufen können wir mit 



```
make tests
```

überprüfen ob alles soweit funktioniert. Ein make install ist nicht notwendig! 


*Einrichten eines  verschlüsselten Containers:*

Wir legen einen Container mit Namen ,,geheim" und 50MB grösse an: 



```
dd if=/dev/zero of=/geheim bs=1024 count=51200
losetup -e AES256 /dev/loop0 /Pfad/zu/geheim  (min. 20 stelliges Passwort eingeben)
mke2fs /dev/loop0                             (ext2 Filesystem anlegen)
losetup -d /dev/loop0                         (aushängen des Devices)
```

Mounten können wir unsere verschlüsselte Datei mit: 



```
losetup -e AES256 /dev/loop0 geheim 
mount /dev/loop0 -t ext2 /mnt/crypt -o loop
```


Den Ordner /mnt/crypt haben wir vorher angelegt.


Entmounten mit folgenden Befehl: 



```
umount /mnt/crypt
losetup -d /dev/loop0
```



Ein Beispiel für den Eintrag in der /etc/fstab könnte so aussehen: 



```
/home/user/geheim /mnt/crypt ext2 defaults,user,noauto,loop=/dev/loop0,encryption=AES256 0 0
```



*Einrichten einer verschlüsselten Partition:*



```
losetup -e AES256 /dev/loop0 /dev/hda7  (min. 20 stelliges Passwort eingeben)
mkfs -t ext2 /dev/loop0                 (ext2 Filesystem erstellen)
losetup -d /dev/loop0                   (aushängen des Devices)
mkdir /mnt/crypted
```

Eintrag in die /etc/fstab: 



```
/dev/hda7 /mnt/crypted ext2 defaults,loop=/dev/loop0,encryption=AES256 0 0
```



*Bereits bestehende Partitionen:*

Mit aes-pipe kann eine bereits bestehende Partition verschlüsselt werden. Aespipe ist ebenfalls bei dem Link von loop-aes erhältlich. Allerdings sollten die Daten vorher gesichert werden. Der entsprechende Befehl könnte so lauten: 



```
aespipe -e AES256 -T < /dev/hda7 > /dev/hda7
```

----------


## DaGrrr

*loop-aes Modul mit weiteren Algorithmen*

Mit dem Modul loop-aes ist es auch möglich weitere Algorithmen zu verwenden. Twofish, serpant oder blowfish.
Um diese Algorithmen nutzen zu können ist es notwenig wie bei loop-aes ein weiteres Modul zu bauen.
Es wird empfohlen, dass AES_Linux_Windows howto als erstes zu beginnen. Wir brauchen wie beim Original loop-aes Modul, die gepatchten util-linux.

*Installation:*

Bauen des Kernel-Moduls:

Als erstes laden wir uns das benötigte File ciphers-VERSION.tar.bz2 herunter.

loop-aes ciphers: http://loop-aes.sourceforge.net/ciphers/

und entpacken es:



```
tar xjvf ciphers-VERSION.tar.bz2
```


Im neu angelegten Verzeichnis ciphers* bauen wir nun das neue Modul:



```
make
```

Ein make install ist nicht notwendig!


Nun können wir auch hier wieder mit


```
make tests
```

überprüfen ob alles ok ist.

Die Überprüfung dauert nun ein wenig länger, da 3 cipher auf funktionsfähigkeit überprüft werden müssen.

Nun können wir wieder einen Container mit twofish 256Bit anlegen:



```
dd if=/dev/zero of=/geheim bs=1024 count=51200
losetup -e TWOFISH256 /dev/loop0 /Pfad/zu/geheim  (min. 20 stelliges Passwort eingeben)
mke2fs /dev/loop0                                 (ext2 Filesystem anlegen)
losetup -d /dev/loop0                             (aushängen des Devices)
```

oder eine Partition erstellen:



```
losetup -e TWOFISH256 /dev/loop0 /dev/hda7  (min. 20 stelliges Passwort eingeben)
mkfs -t ext2 /dev/loop0                     (ext2 Filesystem anlegen)
losetup -d /dev/loop0                       (aushängen des Devices)
mkdir /mnt/crypted
```

Folgende Algorithmen und Bitlängen sind möglich:


```
twofish128   twofish160   twofish192   twofish256
blowfish128  blowfish192  blowfish256
serpent128   serpent192   serpent256
```

Je nachdem für was und für welchen cipher wir uns entschieden haben können wir dieses wie im 
AES_Linux_Windows-howto, die Partition oder Cryptdisk mounten. Ebenso funktioniert der fstab Eintrag. Natürlich muss dann immer der cipher Eintrag entsprechend geändert werden.

----------


## DaGrrr

*Datensicherung mit verschlüsselten CDs und DVDs*



In meinen bisherigen Howto über loop-aes, habe ich beschrieben, wie man loop-aes einrichtet, einen verschlüsselten Container oder eine verschlüsselte Partition einrichtet. Nun möchte ich zeigen, wie man eine verschlüsselte CD / DVD für eine Datensicherung erstellt.

In diesem Howto gehe ich davon aus, dass loop-aes bei dir eingerichtet ist und funktioniert.
Ebenfalls muss das Programm aespipe installiert worden sein. 


*Image erstellen:*

Als Beispiel werde ich das Verzeichnis /etc sichern, da hier meine sämtlichen Konfigurationen und Passwörter für das System liegen.

Folgender Befehl erstellt ein verschlüsseltes CD-Image des /etc Verzeichnisses und legt es als etc_backup.iso im aktuellen Verzeichnis ab.



```
mkisofs -r /etc | /usr/local/bin/aespipe -e AES256 -T > etc_backup.iso
```


*Erklärung zu dem Befehl:*

mkisofs = creiert ein ISO9660 Filesystem

-r = UID und GID werden auf Null gesetzt

/etc = das zu sichernde Verzeichnis

| = weiterleiten an ...

/usr/local/bin/aespipe = Pfadangabe zum Programm aespipe

-e AES256 = welchen Algorithmus und Bitlänge wir benutzen 

-T = Fragt 2x nach dem Passwort (sicher ist sicher)

> etc_backup.iso = in die besagte Datei schreiben


*Anmerkung:*

- aespipe zeigt den Passworteingabeprompt erst beim verifizieren des Passworts an, also

lasse dich nicht verunsichern. Das Passwort muss mindestens 20 Zeichen lang sein.

- Die Größe des Images wird nicht überprüft! Man sollte daher selbst schauen ob das Image 

auf das gewählte Medium passt.


*Testen des Images:*

Bevor wir das soeben erstellte Image auf eine CD / DVD brennen sollten wir es vorher testen.



```
mount -t iso9660 etc_backup.iso /mnt/test -o loop=/dev/loop0,encryption=AES256
```


Nach Eingabe des Passwortes ist das ISO-Image im Verzeichnis /mnt/test gemountet.


*Erklärung zum Befehl:*

mount = der Mountbefehl

-t iso9660 = Angabe des Filesystems

etc_backup.iso = unser zuvor erstelltes Image

/mnt/test = Mountpoint

-o loop=/dev/loop0, = zusätzliche Option, welches loop-Device bnutzt wird

encryption=AES256 = welchen Algorithmus und Bitlänge wir benutzen


Hat alles geklappt können wir das Image unmounten.



```
umount /mnt/test
```



*Image brennen:*

Das CD-Image brennen wir mit cdrecord, für DVDs nehmen wir das Programm growisofs aus dem

dvd+rw-tools Paket.


*CD:*



```
cdrecord -v dev=/dev/hdd etc_backup.iso
```


*DVD:*



```
growisofs -Z /dev/hdd=etc_backup.iso
```

Die verschlüsselte CD / DVD mounten:

Die soeben erstellte CD oder DVD mounten wir nun. 



```
mount -t iso9660 /dev/hdd /mnt/test -o loop=/dev/loop0,encryption=AES256
```

Entmounten können wir wie gewohnt mit:



```
umount /dev/hdd
```

----------


## DaGrrr

*Verschlüsseln der Swap-Partition mit loop-aes*

Bei diesem Teilabschnitt gehe ich davon aus, das loop-aes bei dir eingerichtet ist und funktioniert.

Eine Swap-Partition oder auch Auslagerungsspeicher genannt, ist die Bezeichnung für Speicherplatz, der auf einer Festplatte eingerichtet wird, um scheinbar den verfügbaren Arbeitsspeicher des Systems zu vergrößern. 
Wenn wir mit unserem System gearbeitet haben und auch unsere loop-aes Partition/Container genutzt haben, so könnten sich Daten auf der Swap-Partition 
befinden und wären lesbar für jemanden der z.B. das Notebook stiehlt.
Da wir das gerne verhindern möchten, nun eine Erklärung, wie wir die Swap-Partition ebenfalls mit loop-aes verschlüsseln können.

Als erstes müssen wir folgenden Befehl ausführen, während wir uns in unserem util-linux Sourcenverzeichnis/mount befinden:



```
install -m 755 swapon /sbin
```

Da das Programm "swapon" ebenfalls vom loop-aes Patch gepatcht wurde,
brauchen wir diese Datei.

Wir schalten die laufende Swap-Partition ab.



```
swapoff -a
```

Dabei werden alle Swap-Paritionen abgeschaltet, die in der /etc/fstab eingetragen sind.

Nun schreiben wir neue Informationen in die /etc/fstab:



```
/dev/hdXY   none    swap    sw,loop=/dev/loop1,encryption=AES256   0 0
```

Da wie gesagt noch alte unverschlüsselte Daten sich auf der Swap befinden könnten, werden wir diese erstmal überschreiben:



```
dd if=/dev/zero of=/dev/hdXY bs=64k conv=notrunc
mkswap /dev/hdXY
```

Nun starten wir unsere Swap wieder mit dem Befehl:



```
swapon -a
```

und führen danach



```
rm -rf /var/log/ksymoops
```

 aus.

Bei loop-aes für eine Swap-Partition ist kein Passwort notwendig, da Zufallsschlüssel benutzt werden, der für die laufende Session gültig ist und bei einem Neustart des Systems oder aushängen und wieder einhängen der Swap neu generiert wird. 

Nun ist die Swap-Partition ebenfalls mit loop-aes verschlüsselt.

----------


## DaGrrr

*loop-aes in einem monolitischen Kernel*

Bisher wurde loop-aes als Modul in den Kernel eingebunden. Es gibt auch die Möglichkeit den Kerneltreiber fest in den Kernel zu integrieren. Ein monolitischer Kernel benutzt keine Module, dass heißt jeder Treiber ist im Kernel fest einkompiliert. Auf Server Systemen wo sich die Hardware sehr selten ändert, sowie aus Sicherheitsbedenken wird diese Art von Kernelbau bevorzugt eingesetzt.

Um dem Kernel loop-aes beizubringen muß dieser natürlich neu erstellt werden.

Daher entpacken wir als erstes das loop-aes Paket mit



```
tar xjvf loop-AES-VERSION.tar.bz2.tar
```

Im erstellten loop-aes-VERSION Verzeichnis finden wir zwei Kernelpatches:



```
kernel-2.4.x.diff und kernel-2.6.x.diff
```

In der loop-aes-v3.0d Version, ist der Patch für die Kernelversion linux-2.6.12 vorhanden.
Da ich gerne einen 2.6.x Kernel haben möchte, nehme ich den kernel-2.6.12.diff patch und lade mir daher auf Kernel.org die Linuxversion 2.6.12 herunter.

Nach entpacken des Kernels und kopieren des kernel-2.6.12.diff Patches in das Kernelverzeichnis
müssen wir nun noch die Original loop.c und loop.h löschen. Das ist nötig, weil es sonst beim patchen zu Fehlern kommt.

Wir führen die Befehle



```
rm drivers/block/loop.c &&  rm include/linux/loop.h
```

aus, während wir noch im Kernelverzeichnis sind.

Nun können wir den Kernel patchen:



```
patch -p1 < kernel-2.6.12.diff
```

Gab es hier keine Fehlermeldungen, dann ist die Kernelkonfiguration als nächstes dran.

*Anmerkung:* Gab es beim patchen Fehler, so wird loop-aes nicht funktionieren!

Wir konfigurieren loop-aes im Kernel --> Device Drivers --> Block devices und aktivieren dort 


```
<*> Loopback device support[*] AES encrypted loop device support
```

wie im Bild (Anhang) zu sehen.

Haben wir das erledigt und den Rest des Kernels nach unseren Wünschen konfiguriert, können wir nun wie gewohnt den Kernel kompilieren und ins System einbinden.

Nach neustart des Systems steht loop-aes zur Verfügung und kann wie in den anderen Artikeln erklärt, genutzt werden.

*Anmerkung:* In einem monolitischen Kernel können wir die anderen Algrithmen, wie z.B. Twofish, Serpant oder Blowfish nicht nutzen, da es bisher nur möglich ist, diese als Modul einzubinden.

----------


## DaGrrr

*Windows:*


Für Windows gibt es das Opensource Produkt CrossCrypt, mit dem man wie unter Linux AES verschlüsselte Container oder sogar eine verschlüsselte CD anlegen kann. Mit CrossCrypt kannst du 
z.B. auf einen unter Linux mit loop-aes erstellten Container zugreifen und anders herum.


*Download:*

CrossCrypt: www.scherrer.cc/crypt/

CrossCrypt GUI: http://www.fortunecity.com/skyscrape...ssCryptGUI.htm


Nachdem wir CrossCrypt entpackt haben zb nach c:\crosscrypt können wir die install.bat ausführen. Dabei werden die Dateien entsprechend an den richtigen Orten installiert. Danach sollten wir einen Neustart von Windows durchführen, damit die Registry neu eingelesen wird. 

Es gibt nun zwei Möglichkeiten mit Crosscrypt zu arbeiten, entweder in der Windows Command Shell oder mit der GUI. Die GUI ist recht einfach gestrickt und es sollte jeder mit klar kommen. 


*Für alle hier eine kurze Erklärung der Shellbefehle:*


Neuen verschlüsselten Container anlegen



```
filedisk /mount c:\test.img 100M i: /t /aes256
```


Wir können dann unser Passwort vergeben (minimum 20 Zeichen) und formatieren unseren Container. 

Mit dem obigen Befehl haben wir eine Datei test.img auf dem Laufwerk c:\ angelegt mit 100MB grösse und einer Verschlüsselung mit 256Bit (AES), sowie nach i:\ (Laufwerk, virtuell) gemountet.


Einen existierenden Container mounten:



```
filedisk /mount c:\test.img i: /aes256
```


Eine verschlüsselte CD erstellen:



```
filedisk /encrypt d: c:\test.iso
```


Mit diesem Befehl grabbe ich die vorhandene CD und lege sie als Image auf meine Festplatte, d wäre hier unser CD Laufwerk. Nun verschlüsseln wir das Image mit dem Befehl: 



```
filedisk /encrypt c:\test.iso c:\test.iso /aes256
```


Nach der Passworteingabe können wir das Image anschliessend zb mit Nero Burning ROM auf CD brennen.


Eine verschlüsselte CD mounten:



```
filedisk /mount d: i: /cd /aes256
```

d: wäre hier wieder unser CD-ROM und i: das virtuelle Laufwerk.



umounten der CD:



```
filedisk /umount i:
```

Das virtuelle Laufwerk wird ausgehangen. 

- Eine Verschlüsselung von einem Container / CD entfernen:



```
filedisk /decrypt test.iso plain.iso /aes256
```

plain.iso /aes256 plain.iso ist ein anderer Name als das verschlüsselte test.iso, die beiden dürfen nicht den gleichen Namen haben.

ausgeben aller gemounteten Geräte



```
filedisk /status
```

Gibt den Status aller eingehängten virtuellen Laufwerke aus.

*Windows / Linux:*

Nun kann zb von Linux aus auf einem CrossCrypt Container auf einer FAT Partition zugegriffen und entschlüsselt werden. Ebenfalls ist es möglich von Windows aus auf eine ext2/3 Partition zuzugreifen. Damit das funktioniert benötigt Windows noch die ext2/3 Treiber. Alternativ könnt ihr aber auch den Container auf die jeweilige Partition kopieren. 


Die ext2/3 Treiber könnt ihr hier herunterladen: 


http://uranus.it.swin.edu.au/~jn/linux/ext2ifs.htm

----------


## DaGrrr

*Anhang*



```
#!/bin/bash

#####################
#                   #
# install-aes-tools #
#                   #
#################################
#                               #
# no warranty, no license terms #
# do whatever you like with     #
# this script :)                #
#                               #
# (c) Thorsten Hirsch, 2004     #
#                               #
#################################

# which versions do we want to use?
UTIL_LINUX_VERSION="2.12q"
LOOP_AES_VERSION="3.0d"

# now let's download and extract them if they aren't already here
echo "This script installs patched versions of"
echo "the loop kernel module and some util-linux"
echo "programs in order to use loop-aes."
echo
echo "Press  to continue..."
read
echo
echo "downloading sources..."
echo
if [ -e util-linux-$UTIL_LINUX_VERSION.tar.bz2 ]; then
  echo "  util-linux is already here :)"
else
  wget http://www.kernel.org/pub/linux/utils/util-linux/util-linux-$UTIL_LINUX_VERSION.tar.bz2
fi
if [ -e loop-AES-v$LOOP_AES_VERSION.tar.bz2 ]; then
  echo "  loop-AES is already here :)"
else
  wget http://loop-aes.sourceforge.net/loop-AES/loop-AES-v$LOOP_AES_VERSION.tar.bz2
fi
tar jxf util-linux-$UTIL_LINUX_VERSION.tar.bz2
tar jxf loop-AES-v$LOOP_AES_VERSION.tar.bz2

# install the new kernel module and remove the old one
echo
echo "compiling & installing new loop module..."
echo
cd loop-AES*
make clean
make
rm /lib/modules/`uname -r`/kernel/drivers/block/loop.*
rm /lib/modules/`uname -r`/kernel/drivers/block/cryptoloop.*

# patching util-linux
echo
echo "patching util-linux..."
echo
cd ../util-linux*
patch -p1 < ../loop-AES*/util-linux*.diff

# install the patched programs we need
echo
echo "compiling some util-linux programs..."
echo
CFLAGS=-O2 ./configure
make SUBDIRS="lib mount"
echo
echo "installing the new util-linux programs..."
echo
cd mount
install -m 4755 -o root mount umount /bin
install -m 755 losetup swapon /sbin
rm -f /sbin/swapoff && ( cd /sbin && ln -s swapon swapoff )
rm -f /usr/share/man/man8/{mount,umount,losetup,swapon,swapoff}.8.gz
install -m 644 mount.8 umount.8 losetup.8 /usr/share/man/man8
install -m 644 swapon.8 swapoff.8 /usr/share/man/man8
rm -f /usr/share/man/man5/fstab.5.gz
install -m 644 fstab.5 /usr/share/man/man5
cd ..

# and remove the directories we used
echo
echo "removing temporary files & directories..."
echo
cd ..
rm util-linux* -rf
rm loop-AES* -rf

echo "Installation complete."
```

----------


## DaGrrr

Download des Howto als PDF:

Loop-AES PDF

----------

