Estou usando o Ubuntu em um ambiente corporativo, e nossa política de segurança afirma que precisamos usar criptografia de disco completa.

Também tenho um laptop com um SSD mSATA de 32 GB e 750 GB de ferrugem. Minha instalação atual usa o bcache para aproveitar isso, instalado usando este procedimento . Isso fornece um aumento de desempenho muito bem-vindo sem que eu precise me preocupar em encher o SSD.

Esta será uma questão de recompensa. A recompensa será concedida por:

• Um método claro e confiável de executar uma nova instalação do Ubuntu
  • Qualquer versão é aceitável, mas 15.04 (Vivid) ficará bem
• Todo o sistema de arquivos será criptografado
  • A preferência aqui é usar a caixa de seleção relevante no programa instalador padrão da Ubiquity (criptografia dm-crypt)
• O sistema de arquivos será armazenado em cache em um SSD
  • Para preferência, o método kernel dm-cache / lvmcache veja aqui o método para fazer isso com o Debian Jessie
  • O cache também deve ser protegido (ou seja, criptografado)
  • Deve haver uma explicação clara sobre por que o cache também é criptografado

Já tentei o método para o Debian Jessie acima, mas ele se recusa a inicializar para mim. Até o momento, ainda não tentei o método descrito nos comentários aqui .

As soluções postadas serão testadas em uma VM do VirtualBox com dois discos virtuais em branco e uma cópia da versão 15.04 desktop (versão amd64). O Bounty vai para a primeira solução que eu adoto para reinstalar meu hardware real.

Escreva sua solução como se estivesse entrando no wiki da comunidade.

Eu concedi a recompensa - acho que ainda há potencial para uma solução "LUKS-on-LVM" que combine a facilidade da resposta aprovada em apenas uma senha, com o uso de componentes do dispositivo-mapeador.

LVM no LUKS no bcache

Aqui o jogo de bonecas russas é um pouco mais profundo com 3 pilhas / camadas ...

Minha idéia inicial sobre essa questão foi usar uma instalação padrão do Ubuntu com o LVM no LUKS e convertê-lo em um dispositivo de suporte do bcache com blocos, mas não funcionou para mim no meu teste com o LVM.

Além disso, o instalador do ubuntu ( ubiquity ) é muito limitado para ser instalado dentro de um dispositivo bcache preparado com antecedência (pelo menos com LUKS no LVM), portanto, recorremos a um método de fazer as coisas manualmente.

Inicialize no CD / USB ao vivo e escolha "Experimente o Ubuntu" e abra um terminal

Pré-instalação

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

Instalação

Mantenha o terminal aberto e agora execute a instalação. Escolha "Outra coisa" ao particionar e especifique

• sua partição de inicialização ( /dev/sda2)
• sua partição raiz ( /dev/mapper/vg-root)
• sua troca ( /dev/mapper/vg-swap)

e marque a caixa de seleção para formatar suas partições

No final da instalação, não reinicie, apenas clique em "Continuar tentando o ubuntu"

Pós-instalação

No nosso terminal aberto

# 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

Há um bug de reinicialização conhecido do Ubuntu 15.04 no Live CD / USB; portanto, você pode precisar forçar a reinicialização / desligamento

Verifica

Depois de inicializado, você pode verificar se /dev/bcache0é de fato uma partição LUKS com

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

Isso ocorre porque é o cache da sua partição LUKS e agora você acessa seus dados através do dispositivo /dev/bcache0e nunca do dispositivo de suporte original ( /dev/sda3aqui)

Referências

http://bcache.evilpiepirate.org/

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

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

O status do bcache ainda não foi oficialmente fundido no bcache-tools. Você pode tê-lo aqui: https://gist.github.com/djwong/6343451

[1] Pode haver melhores maneiras de fazer isso limpando

LVM em LUKS + LUKS / dm-cache

O instalador do Ubuntu usa a configuração do LVM on LUKS para a criptografia completa do disco.

Se você também deseja usar o dm-cache / lvmcache para aumentar o desempenho, precisará colocar seu conjunto de cache em um volume criptografado para manter a segurança dos seus dados.

Os passos são

• Crie um volume LUKS no dispositivo de bloco de destino
• Estenda o grupo de volumes padrão com o novo volume LUKS criptografado
• Crie os metadados do cache e os volumes de dados no novo volume LUKS
• Ligue-os juntos como um pool de cache
• Vincular esse conjunto de cache ao volume raiz
• Verifique se o novo volume criptografado pode ser montado na inicialização, adicionando-o ao /etc/crypttab
• Verifique se o seu ambiente de inicialização suporta o dm-cache

O script abaixo fornece um exemplo e adicionará um conjunto de cache criptografado a um sistema de arquivos raiz existente. Foi projetado para sistemas que usaram a opção de criptografia de disco padrão no instalador do Ubuntu - ie; disco inteiro particionado e criptografado, sem partições personalizadas etc.

Observe que há muito pouca validação ou programação defensiva neste script. Se destruir o seu sistema de trabalho, essa é sua responsabilidade.

Ligue assim:

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

1. Precisa de raiz para funcionar
2. executar script no bash
3. o nome do script
4. o dispositivo de bloco que você deseja usar (testado apenas com o disco inteiro)
5. o tamanho dos metadados
6. o tamanho dos dados do cache

Os parâmetros de tamanho são, por padrão, em MB: você precisará de uma proporção de 1: 1000 de espaço de metadados para espaço em cache (por exemplo, se seu disco de cache for de 180 GB, você precisará de 180 MB de espaço de metadados e 179820 MB de espaço de dados - você pode arredondar o metadados um pouco mais cautelosos. Há um limite inferior para os metadados de 8 milhões.)

Você será solicitado a fornecer uma senha para o seu volume de cache - serão solicitadas as senhas para AMBOS seus discos durante a inicialização.

Referências

• Usando o novo recurso de cache dos LVMs (Richard Jones)
• Criptografando um sistema inteiro (dm-crypt wiki)
• Comentários sobre o Launchpad Bug # 1423796
• Inicializando o Debian Jessie a partir de um lvmcache

#! / bin / bash
#
# lvmcryptocache
#
# Adicione um pool de cache LVM e anexe-o ao volume raiz
# Incluindo criptografia LUKS
# Supõe que você esteja usando uma configuração "tudo no root"
# Se não estiver, adapte-o se quiser
#
# Script licenciado GPL3 ou posterior
# © Adrian Wilkins maio de 2015
#
# Passe o nome do dispositivo de disco que você está usando como cache
# Idealmente, isso deve ficar totalmente em branco, portanto, execute
#
# dd se = / dev / zero de = / dev / $ {DISK}
#
# por um curto período de tempo para destruir a tabela de partição

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

DISK_NAME = $ (nome base $ CACHE_DISK)

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

# Criar volume LUKS no disco bruto

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

# Começou a tentar resolver o tamanho do disco, mas é complexo
# Vá se quiser, eu fiquei sem extensões
#
# 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))
# 

# Crie novo PV dentro do volume criptografado

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

# Agora adicione o UUID do PHYSICAL DRIVE do conjunto de cache (/ dev / sdb) ao / etc / crypttab
DISK_UUID = $ (ls -al / dev / disk / by-uuid / | grep $ DISK_NAME | awk '{print $ 9}')
echo "UUID $ {CRYPT_VOLUME} = $ {DISK_UUID} nenhum luk, descarte" >> / etc / crypttab

apt-get install --yes ferramentas de provisionamento fino

GANCHO = $ (arquivo temporário)
# Adicione um script de gancho ao initramfs para adicionar as ferramentas e módulos corretos

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

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

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

# Atualizar initramfs

update-initramfs -u

eco Agora reinicie!