Estoy usando Ubuntu en un entorno corporativo, y nuestra política de seguridad establece que tenemos que usar cifrado de disco completo.

También tengo una computadora portátil con una SSD mSATA de 32 GB y 750 GB de óxido giratorio. Mi instalación actual usa bcache para aprovechar esto, instalado usando este procedimiento . Esto proporciona un aumento de rendimiento muy bienvenido sin tener que preocuparme por llenar el SSD.

Esta será una pregunta generosa. La recompensa se otorgará por:

• Un método claro y confiable para realizar una nueva instalación de Ubuntu
  • Cualquier lanzamiento es aceptable pero 15.04 (Vivid) estará bien
• Todo el sistema de archivos estará encriptado
  • La preferencia aquí es usar la casilla correspondiente en el programa de instalación predeterminado de Ubiquity (cifrado dm-crypt)
• El sistema de archivos se almacenará en caché en un SSD
  • Por preferencia, el método kernel dm-cache / lvmcache vea aquí el método para hacer esto con Debian Jessie
  • El caché también debe estar protegido (es decir, encriptado)
  • Debe haber una explicación clara de por qué el caché también está encriptado

Ya he probado el método para Debian Jessie anterior, pero se niega a arrancar por mí. Hasta ahora no he probado el método descrito en los comentarios aquí .

Las soluciones publicadas se probarán en una VM VirtualBox con dos discos virtuales en blanco y una copia de lanzamiento del escritorio 15.04 (versión amd64). Bounty va a la primera solución que adopto para reinstalar mi hardware real.

Escriba su solución como si fuera a entrar en el wiki de la comunidad.

He otorgado la recompensa: creo que todavía hay potencial para una solución "LUKS-on-LVM" que combine la facilidad de la respuesta aprobada en solo tener una contraseña, con solo usar componentes del mapeador de dispositivos.

LVM en LUKS en bcache

Aquí el juego de muñecas rusas es un poco más profundo con 3 pilas / capas ...

Mi idea inicial sobre esta pregunta era usar una instalación predeterminada de Ubuntu con LVM en LUKS y convertirla en un dispositivo de respaldo bcache con bloques, pero no funcionó para mí en mi prueba con LVM.

Además, el instalador de ubuntu ( ubicuidad ) es demasiado limitado para instalarlo dentro de un dispositivo bcache preparado de antemano (al menos con LUKS en LVM), por lo que recurrimos a un método para hacer las cosas manualmente.

Inicie en el CD / USB en vivo y elija "Probar Ubuntu" y abra una terminal

Preinstalar

sudo -i
# Define some variable to avoid confusion and error
luks_part=/dev/sda3
boot=/dev/sda2                    # boot partition
caching_bcache=/dev/sdb           # SSD or partition in SSD

# Do secure erase of encrypted backing and caching device (see Notes [1])
dd if=/dev/urandom of=$luks_part || dd if=/dev/urandom of=$caching_bcache
# Go and grab some coffe, this will take a while...

apt-get install bcache-tools
# Setup bcache caching and backing devices
make-bcache -C $caching_bcache -B $luks_part
# (Optional) Tweak bcache
echo writeback > /sys/block/bcache0/bcache/cache_mode

# Below we now create manually what ubiquity should have done for us
# Setup LUKS device on bcache device
cryptsetup --key-size 512 luksFormat /dev/bcache0
cryptsetup luksOpen /dev/bcache0 crypted

# Setup LVM on LUKS
# You can skip that part if you don't want to use a swap
# or don't want to use multiple partition. Use /dev/mapper/crypted
# as you root latter on
pvcreate  /dev/mapper/crypted
vgcreate vg /dev/mapper/crypted
lvcreate -L 1G vg -n swap
lvcreate -l 100%FREE vg -n root

Instalación

Mantenga la terminal abierta y ahora ejecute la instalación. Elija "Algo más" al particionar y especifique

• su partición de arranque ( /dev/sda2)
• su partición raíz ( /dev/mapper/vg-root)
• su intercambio ( /dev/mapper/vg-swap)

y marque la casilla de verificación para formatear sus particiones

Al final de la instalación, no reinicie, solo haga clic en "Continuar probando ubuntu"

Post-instalación

En nuestra terminal abierta

# Install bcache-tools to add bcache module to initramfs
mount /dev/mapper/vg-root /mnt
mount $boot /mnt/boot
mount -o bind /sys /mnt/sys
mount -o bind /proc /mnt/proc
mount -o bind /dev /mnt/dev
chroot /mnt
# To get apt-get running in the chroot
echo 'nameserver 8.8.8.8' > /run/resolvconf/resolv.conf
apt-get install bcache-tools

# Create /etc/crypttab to add crypted bcached partition
echo "crypted UUID=`blkid -o value /dev/bcache0|head -1` none luks" > /etc/crypttab

exit
sync
umount /mnt/sys
umount /mnt/proc
umount /mnt/dev
umount /mnt/boot
umount /mnt
vgchange -an /dev/mapper/crypted
cryptsetup luksClose crypted
sync

# Reboot & enjoy

Existe un error conocido de reinicio de Ubuntu 15.04 desde Live CD / USB, por lo que es posible que deba forzar el reinicio / apagado

Cheque

Una vez arrancado, puede comprobar que, /dev/bcache0de hecho, es una partición LUKS con

if sudo cryptsetup isLuks /dev/bcache0; then \
    echo "crypted";\
    else echo "unencrypted";\
fi

Esto se debe a que es el caché de su partición LUKS, y ahora accede a sus datos a través del dispositivo /dev/bcache0y nunca desde el dispositivo de respaldo original ( /dev/sda3aquí)

Referencias

http://bcache.evilpiepirate.org/

https://wiki.archlinux.org/index.php/Bcache

https://wiki.archlinux.org/index.php/Dm-crypt

bcache-status aún no se ha fusionado oficialmente en bcache-tools. Puede tenerlo aquí: https://gist.github.com/djwong/6343451

[1] Puede haber mejores formas de hacer esta limpieza

LVM en LUKS + LUKS / dm-cache

El instalador de Ubuntu utiliza la configuración LVM en LUKS para su cifrado de disco completo.

Si también desea utilizar dm-cache / lvmcache para aumentar el rendimiento, deberá colocar su grupo de caché en un volumen cifrado para mantener la seguridad de sus datos.

Los pasos son

• Cree un volumen LUKS en el dispositivo de bloque de destino
• Extienda el grupo de volúmenes predeterminado con el nuevo volumen LUKS cifrado
• Cree los metadatos de caché y los volúmenes de datos en el nuevo volumen LUKS
• Unirlos como un grupo de caché
• Vincula este grupo de caché al volumen raíz
• Asegúrese de que el nuevo volumen cifrado se puede montar en el arranque agregándolo a /etc/crypttab
• Asegúrese de que su entorno de arranque sea compatible con dm-cache

El siguiente script proporciona un ejemplo y agregará un grupo de caché cifrado a un sistema de archivos raíz existente. Fue diseñado para sistemas que han utilizado la opción de cifrado de disco predeterminada en el instalador de Ubuntu, es decir; disco completo particionado y encriptado, sin particiones personalizadas, etc.

Tenga en cuenta que hay muy poca validación o programación defensiva en este script. Si destruye su sistema de trabajo, es su responsabilidad.

Llame así:

# 1   2          3           4     5    6
sudo bash lvmcryptocache /dev/sdb 32M 1968M

1. Necesita raíz para trabajar
2. ejecutar script en bash
3. el nombre del script
4. el dispositivo de bloque que desea usar (solo probado con disco completo)
5. el tamaño de los metadatos
6. el tamaño de los datos de caché

Los parámetros de tamaño están por defecto en MB: necesitará una proporción de 1: 1000 de espacio de metadatos por espacio de caché (por ejemplo, si su disco de caché es de 180 GB, necesitará 180 MB de espacio de metadatos y 179820 MB de espacio de datos; puede redondear el metadatos un poco para ser cautelosos. Hay un límite inferior para los metadatos de 8M.)

Se le solicitará una contraseña para su volumen de caché; se le solicitarán las contraseñas para AMBOS discos durante el arranque.

Referencias

• Uso de la nueva función de caché de LVM (Richard Jones)
• Cifrar un sistema completo (dm-crypt wiki)
• Comentarios en Launchpad Bug # 1423796
• Arrancando Debian Jessie desde un lvmcache

#! / bin / bash
# #
# lvmcryptocache
# #
# Agregue un grupo de caché LVM y adjúntelo al volumen raíz
# Incluyendo el cifrado LUKS
# Asume que está utilizando una configuración "todo en raíz"
# Si no lo eres, adáptalo si quieres
# #
# Script con licencia GPL3 o posterior
# © Adrian Wilkins Mayo 2015
# #
# Pase el nombre del dispositivo de disco que está utilizando como caché
# Idealmente, esto debería estar totalmente en blanco, así que ejecute
# #
# dd if = / dev / zero of = / dev / $ {DISK}
# #
# sobre él por un momento para destruir la tabla de particiones

CACHE_DISK = $ 1
META_SIZE = $ 2
DATA_SIZE = $ 3

DISK_NAME = $ (nombre base $ CACHE_DISK)

CRYPT_VOLUME = $ {DISK_NAME} _crypt
CACHE_PV = / dev / mapper / $ {CRYPT_VOLUME}

# Crear volumen LUKS en disco sin formato

cryptsetup luksFormat $ CACHE_DISK
cryptsetup open --type luks $ CACHE_DISK $ CRYPT_VOLUME

# Comencé a tratar de resolver el tamaño del disco, pero es complejo
# Intenta si quieres, seguí quedando sin extensiones
# #
# DISK_SIZE = $ (fdisk -l | grep "Disco $ {CACHE_DISK}" | awk '{print $ 5}')
# # 
# META_SIZE = $ ((DISK_SIZE / 1000))
# META_SIZE = $ ((META_SIZE + 512))
# MOD = $ ((META_SIZE% 512))
# MOD_OFFSET = $ ((512 - MOD))
# META_SIZE = $ ((META_SIZE + 512)) 
# META_SIZE = $ ((META_SIZE + MOD_OFFSET))
# # 
# DATA_SIZE = $ ((DISK_SIZE - META_SIZE))
# # 

# Crear nuevo PV dentro del volumen cifrado

pvcreate $ CACHE_PV
vgextend ubuntu-vg $ CACHE_PV
lvcreate -L $ {META_SIZE} -n cachemeta ubuntu-vg $ CACHE_PV
lvcreate -L $ {DATA_SIZE} -n cachedata ubuntu-vg $ CACHE_PV
lvconvert --type cache-pool --poolmetadata ubuntu-vg / cachemeta --cachemode writethrough ubuntu-vg / cachedata --yes
lvconvert --type cache --cachepool ubuntu-vg / cachedata ubuntu-vg / root

# Ahora agregue el UUID del conjunto de caché DISCO FÍSICO (/ dev / sdb) a / etc / crypttab
DISK_UUID = $ (ls -al / dev / disk / by-uuid / | grep $ DISK_NAME | awk '{print $ 9}')
echo "$ {CRYPT_VOLUME} UUID = $ {DISK_UUID} ninguna suerte, descartar" >> / etc / crypttab

apt-get install --yes-thin-provisioning-tools

GANCHO = $ (archivo temporal)
# Agregue un script de enlace a initramfs para agregar las herramientas y módulos correctos

echo "#! / bin / sh"> $ GANCHO
echo "PREREQ =" lvm2 "" >> $ GANCHO
echo "prereqs ()" >> $ HOOK
echo "{" >> $ GANCHO
echo "echo \" $ PREREQ \ "" >> $ GANCHO
echo "}" >> $ GANCHO
echo "caso $ 1 en" >> $ GANCHO
echo "prereqs)" >> $ HOOK
echo "prereqs" >> $ GANCHO
echo "salida 0" >> $ GANCHO
eco " ;;" >> $ GANCHO
echo "esac" >> $ GANCHO
echo "if [! -x / usr / sbin / cache_check]; then" >> $ HOOK
echo "salida 0" >> $ GANCHO
echo "fi" >> $ GANCHO
echo ". / usr / share / initramfs-tools / hook-functions" >> $ HOOK
echo "copy_exec / usr / sbin / cache_check" >> $ HOOK
echo "manual_add_modules dm_cache dm_cache_mq dm_persistent_data dm_bufio" >> $ GANCHO

cp $ HOOK / etc / initramfs-tools / hooks / lvmcache
chmod + x / etc / initramfs-tools / hooks / lvmcache

echo "dm_cache" >> / etc / initramfs-tools / modules
echo "dm_cache_mq" >> / etc / initramfs-tools / modules
echo "dm_persistent_data" >> / etc / initramfs-tools / modules
echo "dm_bufio" >> / etc / initramfs-tools / modules

# Actualizar initramfs

update-initramfs -u

echo ¡Ahora reinicie!