Come posso abilitare Ubuntu (usando la crittografia del disco completo) per chiamare LUKSsupend prima di dormire / sospendere nella RAM?


104

Questa domanda è collegata ad un'altra da @Stefan, ma non è un duplicato di essa. Le domande sono leggermente diverse: l'autore voleva semplicemente sapere se questo era stato implementato, mentre chiedevo aiuto specificamente su come farlo (in un modo particolare). Inoltre, l'altra domanda non ha ottenuto risposte utili per gli implementatori, tranne una recente che si è semplicemente collegata al mio tentativo di farlo.

Avendo spiegato il problema "duplicato" ...

Sono su Ubuntu 14.04 utilizzando la crittografia del disco completo (LVM sopra LUKS) e vorrei incorporare luksSuspendnella procedura di sospensione (e uso successivo luksResume) in modo da poter sospendere su RAM senza lasciare il materiale chiave in memoria e il root sbloccato.

Ho provato a portare una sceneggiatura per Arch Linux , finora senza successo: onestamente non ho idea di cosa sto facendo ...

Qualcuno può aiutarmi a port questo (o creare qualcosa di simile da zero)? O almeno qualcuno può indicarmi la documentazione su come agganciare le cose nelle procedure di sospensione e come mantenere disponibili i binari e gli script necessari (come il cryptsetup) anche dopo che tutto l'IO alla radice è stato bloccato (da luksSuspend)?

Per quanto riguarda come mantenere i binari e gli script necessari disponibili per il curriculum, questo post sul blog (anche per Arch) li ha copiati /boot; Vorrei tuttavia usare qualcosa di più nelle righe che Vianney ha usato nella sceneggiatura che ho menzionato prima, perché questo approccio sembra essere un po 'più elegante in questo aspetto.

Non ho raggiunto molto, ma il mio sviluppo può essere trovato su GitHub .


hai provato ad aggiungere il comando di blocco manuale per ibernare / riprendere le azioni? per esempio aggiungendo udisksctl lock -b /dev/sdaa uno script nella /etc/pm/sleep.d/directory?
AliReza Mosajjal,

Grazie, lo esaminerò ... Da quello che posso già dire, questo è più generale del solo LUKS cryptsetup luksSuspendche sto usando, ma d'altra parte richiede lo smontaggio del filesystem. Inoltre, probabilmente non funzionerà in una jail (poiché comunica con il demone udisksd) e non potrebbe essere usato per rimontare / riprendere il filesystem.
Jonas Malaco,

Anche se si rimuove il materiale chiave, probabilmente ci sono altre informazioni riservate in memoria durante la sospensione su RAM. Quindi che senso ha sbarazzarsi solo della chiave luks?
Pefu,

@pefu Bene, in primo luogo, la quantità di informazioni riservate sul disco può essere molto più grande di quella rimasta nella RAM. Inoltre, la capacità dell'attaccante di identificare e / o modificare le informazioni sulla RAM è piuttosto limitata rispetto all'accesso al file system decrittografato.
Jonas Malaco,

@jonasmalacofilho: Bene: considero le mie chiavi private come il materiale più riservato nel mio laptop. Naturalmente anche queste chiavi private sono protette da una passphrase. All'avvio di solito carico queste chiavi e ho un agente in esecuzione che ovviamente ha una copia decifrata di queste chiavi memorizzata da qualche parte nella RAM. Quindi, se il mio computer cade nelle mani di un aggressore sofisticato che è in grado di bypassare qualsiasi protezione del salvaschermo e salvare i dati dalla RAM, sarei fregato anche se avessi distrutto la chiave LUKS nella RAM prima di andare in sospensione. Giusto?
pefu,

Risposte:


1

Mi dispiace dichiarare l'ovvio, ma hai provato ad aggiungere uno script contenente i comandi cryptsetup luksSuspend / luksResume al /usr/lib/pm-utils/sleep.d? In tal caso cosa è successo?

Mi sembrerebbe logico chiamare stop / start i servizi di crittografia e cryptdisks_early anche su ibernazione / ripresa. Chiamare cryptdisks_stop e cryptdisks_start all'interno di uno script pm-utils/sleep.dfarebbe il trucco? Presumo che questo avrebbe lo stesso risultato della chiamata cryptsetup luksSuspenddiretta.


Finora il mio approccio era quello di cambiare pm-suspend. Tuttavia, sembrano esserci ancora alcuni moduli del kernel caricati che richiedono l'accesso al root fs quando si tenta di sospendere (con echo mem > /sys/power/state). Vedi il repository collegato per maggiori dettagli.
Jonas Malaco,

0

La soluzione più vicina che sono riuscito a trovare è questa sceneggiatura del 2013 di proof of concept suspend.sh di Mikko Rauhala.

#!/bin/sh

# A proof of concept script for forgetting LUKS passwords on suspend
# and reasking them on resume.

# The basic idea is to copy all of the files necessary for luksResume
# onto a RAM disk so that we can be sure they'll be available without
# touching the disk at all. Then switch to a text VT to run the resume
# (easier to make sure it'll come up than to do the same with X).

# The suspend itself has to be done from the ramdisk too to make sure it
# won't hang. This is also a reason why this couldn't be reliably done as a
# self-contained /etc/pm/sleep.d script, so to make the concept clear
# (and because I'm lazy) I did just a minimal standalone proof of concept
# instead. Integrating the functionality into the usual pm tools would be
# encouraged. (Though suspend_pmu would apparently need perl on the ramdisk...)

# (C) 2013 Mikko Rauhala 2013, modifiable and distributable under
# CC0, GPLv2 or later, MIT X11 license or 2-clause BSD. Regardless
# of what you pick, there is NO WARRANTY of any kind.

RAMDEV=/dev/ram0
ROOT=/run/cryptosuspend

PATH=/sbin:/bin:/usr/sbin:/usr/bin

# Cleanup not strictly necessary every time but good for development.
# Doing it before rather than after a suspend for debugging purposes

for a in "$ROOT"/dev/pts "$ROOT"/proc "$ROOT"/sys "$ROOT" ; do
    umount "$a" > /dev/null 2>&1
done

if mount | grep -q "$ROOT" ; then
    echo "Cleanup unsuccessful, cryptosuspend root premounted." 1>&2
    exit 2
fi

if grep -q mem /sys/power/state; then
    METHOD=mem
elif grep -q standby /sys/power/state; then
    METHOD=standby
else
    echo "No mem or standby states available, aborting" 1>&2
    exit 1
fi

if ! mount | grep -q "$RAMDEV" ; then
    mkfs -t ext2 -q "$RAMDEV" 8192
    mkdir -p "$ROOT"
    mount "$RAMDEV" "$ROOT"
    mkdir "$ROOT"/sbin "$ROOT"/bin "$ROOT"/dev "$ROOT"/tmp "$ROOT"/proc "$ROOT"/sys
    cp "$(which cryptsetup)" "$ROOT"/sbin
    for a in $(ldd "$(which cryptsetup)" | grep "/" | cut -d / -f 2- | cut -d " " -f 1) ; do
        mkdir -p "$ROOT""$(dirname /$a)"
        cp "/$a" "$ROOT"/"$a"
    done
    cp "$(which busybox)" "$ROOT"/bin/
    ln -s busybox "$ROOT"/bin/sh
    ln -s busybox "$ROOT"/bin/sync
    cp -a /dev "$ROOT"
    mount -t proc proc "$ROOT"/proc
    mount -t sysfs sysfs "$ROOT"/sys
    mount -t devpts devpts "$ROOT"/dev/pts
fi

CRYPTDEVS="$(dmsetup --target crypt status | cut -d : -f 1)"

echo '#!/bin/sh' > "$ROOT"/bin/cryptosuspend
echo "sync" >> "$ROOT"/bin/cryptosuspend
echo "for a in $CRYPTDEVS ; do" >> "$ROOT"/bin/cryptosuspend
echo "  cryptsetup luksSuspend \$a" >> "$ROOT"/bin/cryptosuspend
echo "done" >> "$ROOT"/bin/cryptosuspend
echo "echo -n \"$METHOD\" > /sys/power/state" >> "$ROOT"/bin/cryptosuspend
echo "for a in $CRYPTDEVS ; do" >> "$ROOT"/bin/cryptosuspend
echo '  while ! cryptsetup luksResume'" \$a ; do" >> "$ROOT"/bin/cryptosuspend
echo "    true" >> "$ROOT"/bin/cryptosuspend
echo "  done" >> "$ROOT"/bin/cryptosuspend
echo "done" >> "$ROOT"/bin/cryptosuspend
chmod a+rx "$ROOT"/bin/cryptosuspend

sync
exec openvt -s chroot "$ROOT" /bin/cryptosuspend

Alcuni lavori sono stati fatti per il porting di questo su Ubuntu 14.04 qui. Questa non è affatto una soluzione perfetta in quanto vi sono ancora alcuni problemi aperti e sembra che dall'11 giugno 2014 non sia stato pubblicato alcun lavoro. Tuttavia, sembra un buon punto di partenza per lo sviluppo futuro.

Fonte: https://github.com/jonasmalacofilho/ubuntu-luks-suspend

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.