Správa několika šifrovaných disků v praxi

9.8.2009 15:01 | Přečteno: 1704× | Linux | | poslední úprava: 9.8.2009 19:25

Pracuji v jedné firmě, jejíž bezpečnostní politika vyžaduje, aby byla veškerá firemní data v počítači zašifrovaná. K tomuto účelu je v celé firmě využíván TrueCrypt (kvůli multiplatformosti - máme jak pracovní stanice jak s Linuxem, tak s Windows). Výměna dat mezi stanicemi probíhá v mnoha případech taky v podobě souborových "disků" zašifrovaných pomocí TrueCrypt. Protože jsem člověk v jistém smyslu líný a nechci si pamatovat až 200-bitová (až 40 alfanumerických znaků + specialní znaky) hesla, vytvořil jsem si sadu skriptů pro práci se zašifrovanými oddíly.

Moje řešení se skládá z vytvoření bezpečnostního tokenu na SD kartě (bohužel nemám na svém notebooku k dispozici ani čtečku SMART karet ani snímač otisku prstu). Na této SD kartě je Truecrypt oddíl, na kterém jsou uloýženy soubory s klíčem a hesly k šifrovaným oddílům (ať už fyzickým nebo souborovým). Protože jsou všechna data na kartě šifrovaná, nemyslím si, že by tím bezpečnost dat příliš trpěla. (Přesto doporučuji nastavit přístupová práva ke všem souborům na SD kartě pouze pro uživatele root)

Vytvoření "tokenu"

Nejprve je třeba si připravit "token", na který pak uložíme soubory s klíčem k šifrovaným oddílům. Nejlepším řešením je samozřejmě pravý token podporující PKCS11. Bohužel můj notebook není vybaven žádným takovým zařízením, tak jsem se rozhodl použít obyčejnou SD kartu. Stejným způsob se da použít také u USB flash disku.

1. Naformátovat SD kartu, příp. USB flash disk a přidání řádku do /etc/fstab (osobně preferuji připojení pomocí UUID).

# Security SD card
UUID=B5C5-D927 /mnt/security/sd_card vfat rw,noauto,noexec,nodev,nosuid,noatime,uid=chearius,gid=chearius,fmask=0177,dmask=0077

2. Vytvořit TrueCrypt container na SD kartě (popř. zašifrovat celou SD kartu). Např. 50MB šifrocaný oddíl v souboru lze vytvořit příkazem:

truecrypt -t --encryption=AES --hash=SHA-512 --size=52428800 --volume-type=normal --filesystem=none -c /mnt/security/truecrypt.tc

3. Nahrát na kartu (do šifrovaného oddílu) klíče a příp. i soubory obsahující heslo pro přístup k šifrovaným oddílům.

Správa šifrovaných disků

Pro připojování a odpojování šifrovaných oddílů, ať už fyzických nebo souborových, jsem vytvořil několik shellových skriptů. Moje požadavky na jednoduchost připojování či odpojování oddílu jsou následující:

• Možnost automatického připojení vybraných šifrovaných oddílů při startu systému
• Automatické odpojení všech připojených šifrovaných oddílů, které skripty spravují
• Možnost jednoduchého připojení šifrovaného oddílu bez uvádění "zbytečných" parametrů

Konfigurační soubory

Celé řešení využívá dva konfigurační soubory. Jeden v adresáři /etc - /etc/truecrypttab a druhý v kořenovém adresáři šifrovaného oddílu na SD kartě, např. /mnt/security/truecrypttab. V prvním konfiguračním souboru jsou uvedeny veškeré udaje nutné pro připojení šifrovaného oddílu na SD kartě, v druhém jsou pak informace o jednotlivých šifrovaných oddílech v počítači.

.

/etc/truecrypttab

# Typ šifrovaného oddílu na SD kartě - soubor (f), zařízení (d)
SECURITY_TYPE=f
# Adresář, kam je připojena SD kartam popř. šifrovaný oddíl
SECURITY_DEVICE=/mnt/security/sd_card
# TrueCrypt oddíl na SD kartě (nepoužívá se, pokud $SECURITY_TYPE = f)
SECURITY_CONTAINER=chearius-laptop.tc
# Kam se má TrueCrypt oddíl na SD kartě připojit
SECURITY_MOUNTPOINT=/mnt/security/truecrypt

# Umístění druhého konfiguračního souboru
TRUECRYPT_TAB=$SECURITY_MOUNTPOINT/truecrypttab

# Automaticky připojit oddíly nastavené v $TRUECRYPT_TAB
AUTOMOUNT=1

# V případě selhání vypnout (restartovat) počítač?
REBOOT_ON_FAIL=0

# V případě selhání se zobrazí obsah souboru
MESSAGE_ON_FAIL=/etc/truecrypt.message

truecrypttab na SD kartě

# Automaticky připojit oddíly s názvem
MOUNT="data ka"

# Typ oddílu - soubor (f), zařízení (d)
MOUNT_home_TYPE=d
# Zařízení
MOUNT_home_DEVICE=/dev/sda7
# Kam připojit
MOUNT_home_MOUNTPOINT=/home
# Kde jsou umístěny soubory s klíči
MOUNT_home_KEYFILES=$SECURITY_MOUNTPOINT/Truecrypt/home.key
# Kde je umístěno heslo - pokud není vyplněno, bude uživatel při připojení dotázán
MOUNT_home_PASSWORD=$SECURITY_MOUNTPOINT/Truecrypt/home.pwd

MOUNT_ka_TYPE=f
# Soubor
MOUNT_ka_FILE=/mnt/data/truecrypt/ka.tc
MOUNT_ka_MOUNTPOINT=/home/data/truecrypt/ka
MOUNT_ka_KEYFILES=$SECURITY_MOUNTPOINT/Truecrypt/ka.key
MOUNT_ka_PASSWORD=$SECURITY_MOUNTPOINT/Truecrypt/ka.pwd

MOUNT_data_TYPE=d
MOUNT_data_DEVICE=/dev/sda3
MOUNT_data_MOUNTPOINT=/mnt/data
MOUNT_data_KEYFILES=$SECURITY_MOUNTPOINT/Truecrypt/sda3.key
MOUNT_data_PASSWORD=$SECURITY_MOUNTPOINT/Truecrypt/sda3.pwd

Jednoduche připojování a odpojování

O jednoduché připojování a odpojování nakonfigurovaných šifrovaných oddílů se stará skript /sbin/mount.truecrypt se symlinkem na /sbin/umount.truecrypt.

#!/bin/bash

. /etc/truecrypttab
. $TRUECRYPT_TAB

automount() {
        for mount in $MOUNT; do
                mount $mount
        done
}

autoumount() {
        mounts=`/usr/bin/truecrypt -t -l | awk '{ print $2 }'`

        for mount in $mounts; do
                mountname=`grep $mount $TRUECRYPT_TAB | awk -F_ '/MOUNT_(.*)_(FILE|DEVICE)/ { print $2 }'`

                if [[ $mountname ]]; then
                        umount $mountname
                fi
        done
}

mount() {
        echo "Mounting device: $1"

        var=MOUNT_$1_TYPE
        type=${!var}

        if [[ $type == "d" ]]; then
                var=MOUNT_$1_DEVICE
                device=${!var}
        elif [[ $type == "f" ]]; then
                var=MOUNT_$1_FILE
                device=${!var}
        else
                echo "Unknown type for mount $1. Check your configuration"
                return 1
        fi

        var=MOUNT_$1_MOUNTPOINT
        mountpoint=${!var}

        var=MOUNT_$1_KEYFILES
        keyfiles=${!var}

        var=MOUNT_$1_PASSWORD

        if [ -f ${!var} ]; then
                password=`cat ${!var}`
        else
                password=${!var}
        fi

        params="-t --keyfiles=$keyfiles --protect-hidden=no"

        if [[ $password ]]; then
                params="${params} --password=$password"
        fi

        /usr/bin/truecrypt $params $device $mountpoint
}

list() {
        mounts=`/usr/bin/truecrypt -t -l | awk '{ print $2 }'`

        for mount in $mounts; do
                mountname=`grep $mount $TRUECRYPT_TAB | awk -F_ '/MOUNT_(.*)_(FILE|DEVICE)/ { print $2 }'`

                if [[ $mountname ]]; then
                        echo "$mountname (${mount})"
                fi
        done
}

umount() {
        echo "Unmounting device: $1"

        var=MOUNT_$1_TYPE
        type=${!var}

        if [[ $type == "d" ]]; then
                var=MOUNT_$1_DEVICE
                device=${!var}
        elif [[ $type == "f" ]]; then
                var=MOUNT_$1_FILE
                device=${!var}
        else
                echo "Unknown type for mount $1. Check your configuration"
                return 1
        fi

        var=MOUNT_$1_MOUNTPOINT
        mountpoint=${!var}

        mounted=`/usr/bin/truecrypt -t -l | grep "${device}.*${mountpoint}"`

        if [[ $mounted ]]; then
                /usr/bin/truecrypt -t -d $device
        else
                echo "$1 is not mounted!"
        fi
}

script=`basename $0`

if [[ $script == "mount.truecrypt" ]]; then
        if [ $# -eq 0 ]; then
                list
        elif [ $# -gt 1 ]; then
                echo "Usage: $0 [-a]|[mount]"
        else
                if [[ $1 == "-a" ]]; then
                        automount
                else
                        mount $1
                fi
        fi
else
        if [ $# -eq 0 ]; then
                list
        elif [ $# -gt 1 ]; then
                echo "Usage: $0 [-a]|[mount-point]"
        else
                if [[ $1 == "-a" ]]; then
                        autoumount
                else
                        umount $1
                fi
        fi
fi

Použití skriptu je velmi jednoduché. Skript spuštěný bez parametru zobrazí aktualně připojené, skriptem spravované oddíly. Skript spuštěný s parametrem -a připojí automaticky všechny oddíly nakonfigurované v proměnné $MOUNT, resp. odpojí všechny aktuálně připojené, skriptem spravované oddíly. Pokud je jako první parametr uveden název konfigurace oddílu, bude tento připojen, resp. odpojen.

Automatické připojení při startu

O automatické připojení "tokenu" a vybraných šifrovaných oddílů se starají dva skripty: /etc/rc.truecrypt a /etc/rc.truecrypt.shutdown. Oba skripty používají některé funkce z inicializačních skriptů distribuce ArchLinux, jmenovitě soubor /etc/rc.d/functions (funkce stat_busy, stat_done a stat_fail). Pro použití skriptů v jiných distribucích bude zřejmě nutné nahradit, příp. odstranit tyto funkce.

/etc/rc.truecrypt

Tento skript se spouští ze skriptu /etc/rc.sysinit tesně po té, co byly připojeny lokální souborové systémy a aktivován swap (v mém systému řadek 299).

#!/bin/bash

. /etc/truecrypttab
. /etc/rc.d/functions

test_result() {
	if [ $1 -eq 0 ]; then
		stat_done;
	else
		stat_fail

		if [ $2 -eq 1 ]; then
			if [ $MESSAGE_ON_FAIL -o -f $MESSAGE_ON_FAIL ]; then
				cat $MESSAGE_ON_FAIL
				echo ""
				echo "Press any key to continue ..."
				read -n 1 response
			fi
	
			if [ $REBOOT_ON_FAIL -eq 1 ]; then
				echo "Shutting down ..."
				/sbin/shutdown -h now
			else
				echo "Exiting ..."
				exit
			fi
		fi
	fi
}

retry() {
	echo "Serious problems occured. Do you want to retry? Press Y to retry or N to exit."
	read -n 1 response

	if [[ $response =~ [nN] ]]; then
		return 1
	else
		return 0
	fi
}

mount_security() {
	stat_busy "Mounting security device"
	/usr/bin/truecrypt -t --keyfiles="" --protect-hidden=no $SECURITY_DEVICE $SECURITY_MOUNTPOINT

        exit_code=$?

        if [ $exit_code -ne 0 ]; then
                retry

                if [ $? -eq 0 ]; then
                        mount_security
                        exit_code=0
                fi
        fi

        test_result $exit_code 1
}

mount_security_device() {
	SECURITY=`grep $SECURITY_DEVICE /etc/mtab`

	if [[ !($SECURITY =~ $SECURITY_DEVICE) ]]; then
		stat_busy "Mounting security device"
		/bin/mount /mnt/security/sd_card
			
		exit_code=$?

		if [ $exit_code -ne 0 ]; then
			retry

			if [ $? -eq 0 ]; then
				mount_security_device
				exit_code=0
			fi
		fi

		test_result $exit_code 1
	fi
}

mount_security_container() {
	stat_busy "Mounting security container"

	if [ -f $SECURITY_DEVICE/$SECURITY_CONTAINER ]; then
		/usr/bin/truecrypt -t --keyfiles="" --protect-hidden=no $SECURITY_DEVICE/$SECURITY_CONTAINER $SECURITY_MOUNTPOINT
		
                exit_code=$?

                if [ $exit_code -ne 0 ]; then
                        retry

                        if [ $? -eq 0 ]; then
                                mount_security_container
				exit_code=0
                        fi
                fi

                test_result $exit_code 1
	else
		echo "File $SECURITY_DEVICE/$SECURITY_CONTAINER not found!"
		exit_code=1

		retry

                if [ $? -eq 0 ]; then
			mount_security_container
			exit_code=0
                fi

		test_result $exit_code 1
	fi
}

automount() {
	if [ $AUTOMOUNT -eq 1 ]; then
		stat_busy "Automounting encrypted volumes"

		/sbin/mount.truecrypt -a

		test_result $? 0
	fi
}

if [[ $SECURITY_TYPE == "d" ]]; then
	mount_security
else
	mount_security_device
	mount_security_container
fi

automount

/etc/rc.truecrypt.shutdown

Tento skript se spouští ze skriptu /etc/rc.shutdown tesně před tím, než je všem procesům zaslán signál SIGTERM (v mém systému řadek 42).

#!/bin/bash

. /etc/truecrypttab
. /etc/rc.d/functions

test_result() {
        if [ $? -eq 0 ]; then
                stat_done;
        else
                stat_fail
                if [ $REBOOT_ON_FAIL -eq 1 ]; then
                        echo "Serious problems occured - rebooting ..."
                        /sbin/shutdown -r now
                else
                        exit
                fi
        fi
}

stat_busy "Unmounting encrypted volumes"
/sbin/umount.truecrypt -a
test_result

stat_busy "Unmounting security container"
/usr/bin/truecrypt -t -d $SECURITY_DEVICE/$SECURITY_CONTAINER
test_result

stat_busy "Unmounting security device"
/bin/umount $SECURITY_DEVICE
test_result

Poznámky

• Skripty jsou napsány a otestovány v distribuci ArchLinux. Je možné, že je bude nutné upravit při použití v jiné distribuci.
• V ArchLinuxu by neměly v souboru /etc/mkinitcpio.conf chybět mezi HOOKS parametry usb a encrypt. Jinak se může stát, že nebude možné při startu systému připojit SD kartu (token).
• Veškeré soubory na SD kartě s klíči a hesly k šifrovaným oddílům by měly mít nastaveny přístupová práva tak, aby je mohl číst a měnir pouze uživatel root.

Závěr

V tomto článku jsem nastínil postup, jak spravovat několik šifrovaných disků pomocí TrueCrypt a sady shell skriptů. Doufám, že se někomu budou hodit / poslouží jako zdroj inspirace. Skripty jsou poskytovány bez jakékoliv záruky, testoval jsem je pouze na svém notebooku (kde fungují bez nejmenších problémů). Pokud máte nějaké připomínky, navrhy na vylepšení, ... podělte se o ně, prosím, v diskusi.

       

Komentáře

[Filip Jirsák]

To by mne zajímalo, kolik vašich kolegů to řeší tak, že má ta hesla prostě v nějakém textovém souboru, který může číst každý. Není nad to postavit bezpečnostní politiku na tom, že si uživatel bude pamatovat spoustu různých dlouhých hesel, která se navíc musí často měnit. To vyjde skoro nastejno, jako vydat doporučení, že si uživatelé mají hesla na lístečcích nalepit na monitor.

To vaše řešení samozřejmě taky snižuje bezpečnost (ale je to nesrovnatelně lepší, než hesla v souboru čitelném pro kohokoli), ale ten, kdo navrhl bezpečnost zvýšit tím, že se veškeré „náklady“ s tím spojené přesunou jen na uživatele, si nic jiného nezaslouží.

[chearius]

Hesla generujeme pomocí programu KeePass a taky jsou v KeePass databázi uložené (hesla jsou ukládána v zašifrované podobě).

Jinak jsem si vědom, že moje řešení jistým způsobem snižuje bezpečnost; na druhou stranu si nemyslím, že by jí to snižovalo nějakým podstatným způsobem ... hesla jsou (ale nemusí být) sice uložena v textových souborech, ovšem na zašifrovaném oddílu a nečitelná pro jiného uživatele, než root ... při ztrátě notebooku se nikdo k datům nedostane.

[Marián Kyral]

Díky za inspiraci, dostal jsem teď v práci nový NB, tak možná něco využiji. Tu SD kartu tam necháváš, nebo ji pokaždé vytáhneš?

[chearius]

SD kartu po vypnutí notebooku vždycky vytáhnu. Většinu času ji nosím v pouzdře v kapse, aby nebyla u notebooku.

[Roger]

Co si poridit nejaky regulerni (USB?) token?

[chearius]

I o této možnosti jsem uvažoval. Nakonec jsem tuto možnost nezvolil jednak kvůli pořizovací ceně tokenu (SD kartu jsem měl k dispozici) a druhak z důvodu velikosti tokenu. Často pracuju s notebookem i na cestách a zastrčený token v notebooku (podobně jako USB flash disk) mi prostě překáží.

[chearius]

Ještě jedna poznámka: docela by mne zajímalo, o kolik je odbobné řešení za použití regulérního tokenu bezpečnější oproti mnou zvolenému řešení. Největší rozdíl oproti tokenu je asi ten, že moje SD karta je připojená po celou dobu běhu systému (ale přístup k ní má pouze root). Jinak mě další velké rozdíly v bezpečnosti nenapadají ... Ale rád se nechám poučit od někoho, kdo této problematice lépe rozumí.

[Filip Jirsák]

SD kartu si může přečíst každý bez problémů, šifrovací token by měl fungovat tak, že má privátní klíč uložen „v sobě“ a nejde z něj běžnými prostředky získat, tj. nejde softwarově přečíst; samozřejmě fyzickému rozebrání tokenu a přečtení vnitřní paměti zabránit nejde.

[Roger]

Samozrejme jde, ale tady uz zalezi na urovni daneho cipu. Pochopitelne, pokud si koupite blbou eepromku, tak si moc nepomuzete, ale rozumna cipova karta je navrzena i s ohledem na fyzickou bezpecnost (treba rozbrouseni atp.).

[Filip Jirsák]

Vzhledem k tomu, že drtivá většina karet i tokenů nemá vlastní vstup hesla/PINu, ale spoléhá na vstup z počítače, nebude to s tou bezpečností běžně dostupných zařízení tak slavné. Pokud s tokenem/kartou komunikuje oprávněná aplikace způsobem „tady máš PIN a data a zašifruj mi to“, může úplně to samé udělat i záškodnická aplikace. Rozdíl je v tom, že nezíská privátní klíč, pouze si – v době, kdy je token/karta k dispozici – může nechat něco zašifrovat. Což pro přístup k souboru chráněnému takovou kartou bohatě stačí.

[petr_p]

Ono je to hlavně rychlejší. Protože výpočetní schopnosti čipových karet a podobných tokenů jsou žalostné. Pokud by se to mělo dělat bezpečněji a výkoněji, bylo by asi třeba hardwarové šifrovací udělátko mezi disk a řadič a TPM modul na desce pro uložení klíčů. V levnějším případě se nechá přes TPM ověřit integrita softwaru a šifrovat se bude na CPU. V ještě levnějším případě se zašifruje úplně celý disk a člověk si s sebou bude tahat jádro se zavaděčem.

[Vašek Lorenc]

 S TPM je to taky tak, že jeho bezpečnost byla v mnoha případech zpochybněna.. Je to celé otázka toho, co ještě je a co není pro daného člověka bezpečné. Co se výkonu čipových karet týče, tak jejich výkon není až tak žalostný, ale problém bývá s rozhraním. Nicméně i to se řeší -- Remotely Keyed Encryption je něco, co by se dalo použít. U TrueCryptu ale stačí mít na kartě uloženou třeba jen hlavičku šifrovaného svazku, protože bez ní se případný útočník stejně moc daleko nedostane..

[petr_p]

S TPM je to taky tak, že jeho bezpečnost byla v mnoha případech zpochybněna..

Tomu bych i věřil. Ale ještě jsem se o to nezajímal, neb takový stroj nevlastním. Máte tip na zajímavé čtení?

U TrueCryptu ale stačí mít na kartě uloženou třeba jen hlavičku šifrovaného svazku, protože bez ní se případný útočník stejně moc daleko nedostane..

Myslím, že smyslem karty je, že ji klíč neopustí. Nikoliv, že si tam odložím klíč, který pak za běhu vrátím do systému.

[Vašek Lorenc]

Na to čtení o TPM se podívám během příštího týdne, bude-li to stačit. Někde ty prameny mám..

A ke smyslu karty -- ono to tak pochopitelně má být, ale ještě dost záleží na tom, co o útočníkovi předpokládáme. Problém s TrueCryptem je v tom, že když už se útočník dostane k počítači tak, že tam má vlastní proces, nejlépe na úrovní oprávnění kernelu, tak stejně může přečíst celý disk -- heslo/data mu poskytne ať už karta, nebo sám uživatel. K tomu, aby se to záškodníkovi nepodařilo (nebo to měl alespoň stížené a uživatel začal tušit nějakou nepravost), by každou operaci se souborem v TrueCryptu musel uživatel nějak explicitně potvrzovat, a to nejlépe na té čipové kartě nebo krypto tokenu (tedy v zařízení, které útočník nemůže jednoduše dostat pod svoji kontrolu).. A to zase nebude úplně pohodlné.

Takže v tomhle ohledu je asi lepší předpokládat, že obrana je proti takovému útočníkovi, který se dostane ke svazku nebo čipovce, možná k obojímu, ale určitě není schopen zjistit PIN a tedy ani vyčíst data z čipovky.

(uff, snad jsem se do toho moc nezamotal)

[Filip Jirsák]

Právě že ke zjištění PINu zadávaného v počítači není vůbec potřeba práva roota. Úplně stačí zobrazit stejné okno, kterým žádá o PIN „systém“, případně jiná aplikace, a to můžete zvládnout možná i s flashem vloženým na webové stránce.

[petr_p]

Jistě, požadavek karty coby tokenu je v tomto případě zbytečně silný (nepočítáme-li remotely keyed encryption). Úplně stejně dobře poslouží jádro a zašifrovaný klíč na USB mass storage.

[Libor Tvrdík]

Pokud jsou pro vás komerční tokeny moc drahé, doporučuji "Výroba levného tokenu" od Rudolfa Marka: Slide, patch, kontakt na autora video záznam.

[Roger]

Slo by neco udelat s tim "probýhá"? Diky.

[chearius]

Díky, opraveno.