Como habilito o Ubuntu (usando criptografia de disco completo) para chamar LUKSsupend antes de dormir / suspender na RAM?

Esta questão está relacionada a outra por @Stefan, mas não é uma duplicata. As perguntas são um pouco diferentes: o autor simplesmente queria saber se isso havia sido implementado, enquanto estou pedindo ajuda especificamente sobre como fazer isso (de uma maneira específica). Além disso, a outra pergunta não obteve respostas úteis para os implementadores, exceto uma recente que apenas se vinculou à minha tentativa.

Tendo explicado o problema "duplicado" ...

Estou no Ubuntu 14.04 usando criptografia de disco completo (LVM na parte superior do LUKS) e gostaria de incorporar luksSuspendao procedimento de suspensão (e uso posterior luksResume) para que eu possa suspender a RAM sem deixar o material principal na memória e a raiz desbloqueada.

Eu tentei portar um script para o Arch Linux , até agora sem sucesso: sinceramente não tenho ideia do que estou fazendo ...

Alguém pode me ajudar a portar isso (ou criar algo assim do zero)? Ou, pelo menos, alguém pode me indicar uma documentação sobre como conectar coisas aos procedimentos de suspensão e como manter os binários e scripts necessários (como o cryptsetup) disponíveis, mesmo depois que todas as E / S para root foram bloqueadas (por luksSuspend)?

Com relação a como manter os binários e scripts necessários disponíveis para retomar, este outro post do blog (também para Arch) os copiou /boot; Gostaria, no entanto, de usar algo mais nas linhas que Vianney usou no script que mencionei antes, porque essa abordagem parece ser um pouco mais elegante nesse aspecto.

Ainda não cheguei muito, mas meu desenvolvimento pode ser encontrado no GitHub .

Desculpe declarar o óbvio, mas você tentou adicionar um script contendo os comandos cryptsetup luksSuspend / luksResume aos /usr/lib/pm-utils/sleep.d? Se sim, o que aconteceu?

Pareceria lógico para mim ligar para parar / iniciar os serviços cryptdisks e cryptdisks_early no hibernate / resume também. Chamar cryptdisks_stop e cryptdisks_start dentro de um script pm-utils/sleep.dfaria o truque? Suponho que isso teria o mesmo resultado que chamar cryptsetup luksSuspenddiretamente.

A solução mais próxima que consegui encontrar é o script suspend.sh de prova de conceito de 2013 de 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

Algum trabalho foi feito para portar isso para o Ubuntu 14.04 aqui. Esta não é de forma alguma uma solução perfeita, pois ainda existem alguns problemas em aberto e parece que nenhum trabalho foi lançado desde 11 de junho de 2014. No entanto, parece um bom ponto de partida para o desenvolvimento futuro.

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