Sto usando Ubuntu in un ambiente aziendale e la nostra politica di sicurezza afferma che dobbiamo usare la crittografia del disco completo.

Ho anche un laptop con un SSD mSATA da 32 GB e 750 GB di ruggine rotante. La mia installazione corrente usa bcache per sfruttare questo, installato usando questa procedura . Ciò fornisce un aumento delle prestazioni molto gradito senza che io debba preoccuparmi di riempire l'SSD.

Questa sarà una domanda generosa. La taglia sarà assegnata per:

• Un metodo chiaro e affidabile per eseguire una nuova installazione di Ubuntu
  • Qualsiasi versione è accettabile ma 15.04 (Vivido) andrà bene
• L'intero filesystem sarà crittografato
  • La preferenza qui è usare la casella di spunta pertinente nel programma di installazione Ubiquity predefinito (crittografia dm-crypt)
• Il filesystem verrà memorizzato nella cache su un SSD
  • Per preferenza, il metodo kernel dm-cache / lvmcache si trova qui per il metodo per farlo con Debian Jessie
  • Anche la cache deve essere protetta (ovvero crittografata)
  • Ci deve essere una chiara spiegazione del perché anche la cache è crittografata

Ho già provato il metodo per Debian Jessie sopra, ma si rifiuta di avviarsi per me. Finora non ho provato il metodo descritto nei commenti qui .

Le soluzioni pubblicate verranno testate su una VM VirtualBox con due dischi virtuali vuoti e una copia di rilascio del desktop 15.04 (versione amd64). Bounty va alla prima soluzione che adotto per reinstallare il mio hardware attuale.

Scrivi la tua soluzione come se stesse entrando nella wiki della community.

Ho assegnato la ricompensa: penso che ci sia ancora potenziale per una soluzione "LUKS-on-LVM" che combina la facilità della risposta approvata con una sola password, utilizzando solo i componenti Device Mapper.

LVM su LUKS su bcache

Qui il gioco della bambola russa è un po 'più profondo con 3 pile / strati ...

La mia idea iniziale su questa domanda era quella di utilizzare un'installazione Ubuntu predefinita con LVM su LUKS e convertirla in un dispositivo di backup bcache con blocchi ma non ha funzionato per me nel mio test con LVM.

Inoltre, il programma di installazione di Ubuntu ( ubiquità ) è troppo limitato per essere installato all'interno di un dispositivo bcache preparato in anticipo (almeno con LUKS su LVM), quindi torniamo a un metodo per fare le cose manualmente.

Avvia il CD / USB live e scegli "Prova Ubuntu" e apri un terminale

Preinstallare

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

Installazione

Tenere aperto il terminale e ora eseguire l'installazione. Scegli "Qualcos'altro" durante il partizionamento e specifica

• la tua partizione di avvio ( /dev/sda2)
• la tua partizione di root ( /dev/mapper/vg-root)
• il tuo swap ( /dev/mapper/vg-swap)

e seleziona la casella di controllo per formattare le tue partizioni

Alla fine dell'installazione, non riavviare ma fai semplicemente clic su "Continua a provare Ubuntu"

Post-installazione

Nel nostro terminale aperto

# 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

Esiste un noto bug di riavvio di Ubuntu 15.04 da Live CD / USB, quindi potrebbe essere necessario forzare il riavvio / spegnimento

Dai un'occhiata

Una volta avviato, è possibile verificare che /dev/bcache0in realtà sia una partizione LUKS con

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

Questo perché è la cache della partizione LUKS e ora accedi ai tuoi dati tramite il dispositivo /dev/bcache0e mai dal dispositivo di backup originale ( /dev/sda3qui)

Riferimenti

http://bcache.evilpiepirate.org/

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

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

bcache-status non è ancora ufficialmente unito in bcache-tools. Puoi averlo qui: https://gist.github.com/djwong/6343451

[1] Potrebbero esserci modi migliori per eseguire questa pulizia

LVM su LUKS + LUKS / dm-cache

Il programma di installazione di Ubuntu utilizza LVM su LUKS configurazione per la sua crittografia completa del disco.

Se si desidera utilizzare anche dm-cache / lvmcache per migliorare le prestazioni, è necessario posizionare il pool di cache in un volume crittografato per mantenere la sicurezza dei dati.

I passaggi sono

• Creare un volume LUKS sul dispositivo a blocchi di destinazione
• Estendi il gruppo di volumi predefinito con il nuovo volume LUKS crittografato
• Creare i metadati della cache e i volumi di dati nel nuovo volume LUKS
• Uniscili come un pool di cache
• Associare questo pool di cache al volume principale
• Assicurarsi che il nuovo volume crittografato possa essere montato all'avvio aggiungendolo a /etc/crypttab
• Assicurarsi che l'ambiente di boot supporti dm-cache

Lo script seguente fornisce un esempio e aggiungerà un pool di cache crittografato a un filesystem di root esistente. È stato progettato per i sistemi che hanno utilizzato l'opzione di crittografia del disco predefinita nel programma di installazione di Ubuntu - vale a dire; intero disco partizionato e crittografato, nessuna partizione personalizzata ecc.

Si noti che la programmazione difensiva o di programmazione difensiva è molto ridotta in questo script. Se distrugge il tuo sistema di lavoro, questa è la tua responsabilità.

Chiama così:

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

1. Ha bisogno di root per funzionare
2. eseguire lo script in bash
3. il nome dello script
4. il dispositivo a blocchi che si desidera utilizzare (testato solo con l'intero disco)
5. la dimensione dei metadati
6. la dimensione dei dati della cache

I parametri di dimensione sono predefiniti in MB: è necessario un rapporto di 1: 1000 di spazio metadati per lo spazio cache (ad es. Se il disco della cache è 180 GB, sono necessari 180 MB di spazio metadati e 179820 MB di spazio dati - si consiglia di arrotondare metadati un po 'più cauti. C'è un limite inferiore per i metadati di 8 M.)

Ti verrà richiesta una password per il volume della cache - ti verranno richieste le password per ENTRAMBE i tuoi dischi durante l'avvio.

Riferimenti

• Utilizzo della nuova funzione cache di LVM (Richard Jones)
• Crittografia di un intero sistema (dm-crypt wiki)
• Commenti sul Launchpad Bug # 1423796
• Avvio di Debian Jessie da un lvmcache

#! / Bin / bash
#
# lvmcryptocache
#
# Aggiungere un pool di cache LVM e collegarlo al volume principale
# Inclusa la crittografia LUKS
# Presuppone che tu stia utilizzando un'impostazione "tutto su root"
# Se non lo sei, adattalo se vuoi
#
# Script con licenza GPL3 o successive
# © Adrian Wilkins Maggio 2015
#
# Passa il nome del dispositivo disco che stai usando come cache
# Questo dovrebbe idealmente essere totalmente vuoto, quindi corri
#
# dd if = / dev / zero of = / dev / $ {DISK}
#
# su di esso per un breve periodo per eseguire il nuke della tabella delle partizioni

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

DISK_NAME = $ (basename $ CACHE_DISK)

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

# Crea volume LUKS nel disco grezzo

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

# Ha iniziato a provare a elaborare elementi di dimensioni del disco ma è complesso
# Prova, se vuoi, ho continuato a corto di estensioni
#
# 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))
# 

# Crea nuovo PV all'interno del volume crittografato

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

# Ora aggiungi l'UUID del pool di cache PHYSICAL DRIVE (/ 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} nessuno luks, scarta" >> / etc / crypttab

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

HOOK = $ (tempfile)
# Aggiungi uno script hook a initramfs per aggiungere i giusti strumenti e moduli

echo "#! / bin / sh"> $ HOOK
echo "PREREQ =" lvm2 "" >> $ HOOK
echo "prereqs ()" >> $ HOOK
echo "{" >> $ HOOK
echo "echo \" $ PREREQ \ "" >> $ HOOK
echo "}" >> $ HOOK
echo "case $ 1 in" >> $ HOOK
echo "prereqs)" >> $ HOOK
echo "prereqs" >> $ HOOK
echo "exit 0" >> $ HOOK
eco " ;;" >> $ HOOK
echo "esac" >> $ HOOK
echo "if [! -x / usr / sbin / cache_check]; quindi" >> $ HOOK
echo "exit 0" >> $ HOOK
echo "fi" >> $ HOOK
echo ". / usr / share / initramfs-tools / hook-funzioni" >> $ HOOK
echo "copy_exec / usr / sbin / cache_check" >> $ HOOK
echo "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

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

# Aggiorna initramfs

update-initramfs -u

echo Ora riavvia!