Criptografar sua atual partição root usando dm-crypt com luks

Autor: Aline de Freitas

Introdução

Há muita discussão pela rede sobre o por quê da necessidade de se
criptografar discos. O mais importante a se pensar ao criptografar os
discos é não se comprometer com os dados que você possa ter em seu
sistema. Não vou entrar no mérito político dos porquês. Acredito que
quem procura por documentação sobre criptografia já está decidida/o a
fazer uso da mesma.

Atualmente há vários métodos de criptografia disponíveis dos
quais por exemplo loop-aes. Minha escolha por cryptsetup-luks com
dm-crypt se deu por ser considerado o método adequado para grande
volume de dados (criptografei meu quase que meu disco todo), por não
ter uma perda muito grande na performance (o ganho com a segurança me
parece compensar esta eventual perda) e por ser considerado o mais
seguro.

Há muito tutoriais na rede sobre o assunto, o principal, pelo qual me baseei é Security System Encryption DM-Crypt with Luks
Alguns métodos de criptografia da partição root incluem o uso de um
pendrive com uma senha criptografada no qual nem mesmo você poderá
saber qual a senha. O problema em relação a este tipo de método é que
se você perder o pendrive ou ele parar de funcionar, você não poderá
NUNCA MAIS descriptografar seu sistema. Assim eu optei por uma
alternativa menos severa mas nem por isso insegura, que é utilizar um
cdrom para bootar o sistema e manter uma partição de boot
não-encriptada para o caso de perda ou danificação do cdrom. Este
método é baseado neste antigo e ultrapassado howto: Encrypted Root Filesystem HOWTO.

Preparativos iniciais

Requerimentos

  • Kernel: >= 2.6.20
  • Suporte para udev
  • Partição de boot separada.
  • Algum mecanismo para backup. No meu caso utilizei um velho disco rígido de 20GB
  • Paciência e persistência.

Preparando o kernel

O seu kernel deve estar configurado com as opções a seguir:

# make menuconfig

General setup —>
            [*] Initial RAM filesystem and RAM disk (initramfs/initrd) support
            ()    Initramfs source file(s) (Deixe este campo em branco!)

Device Drivers  —>
            [*] Multiple devices driver support (RAID and LVM)  —>
                             <*>   Device mapper support
                          <*>     Crypt target support

— Cryptographic API  —>        
                <*>   SHA256 digest algorithm
            <*>   SHA384 and SHA512 digest algorithms
            <*>   Blowfish cipher algorithm
            <*>   Serpent cipher algorithm
            <*>   AES cipher algorithms
se estiver usando um sistema amd64 troque a opção acima por
            <*>   AES cipher algorithms (x86_64)

Então,

# make && make modules modules_install
# mount /boot
# make install

Para quem usa Debian:

# make-kpkg kernel-image
# dpkg -i <o novo kernel>

Obtenha as ferramentas

Verifique se você possui cryptsetup-luks instalado.

# emerge -avn cryptsetup-luks

ou

# apt-get install cryptsetup

Fazendo backup dos dados (obrigatório)

Primeiro precisamos fazer o backup da partição root. Digamos que seu
disco principal seja /dev/sda e sua partição root seja /dev/sda3 e que
o disco para backup seja /dev/sdb. Esta será a referência no decorrer
do tutorial. Não se esqueça de trocar estes valores para a sua
situação. Criamos uma partição única para armazenar os dados que
futuramente serão encriptados:

# fdisk /dev/sdb

O número de cilindros para este disco está configurado para 2491.
Não existe nada de errado, mas isto é maior que 1024,
e pode em certas configurações causar problemas com:

1) programas que executam em tempo de inicialização (versões velhas do LILO)

2) inicialização e programas de particionamento de outros OSs
(p.ex., DOS FDISK, OS/2 FDISK)

Comando (m para ajuda): n
Comando – ação
   l   lógica (5 ou superior)
   p   partição primária (1-4)
p
Número da partição (1-4): 1

Depois enter + enter para utilizar todo o disco e então para salvar:

Comando (m para ajuda): w

# mkfs.ext3 /dev/sdb1

Agora vamos fazer o backup dos dados:

# mkdir /mnt/crypt
# mount /dev/sdb1 /mnt/crypt
# cd /
# cp -avx / /mnt

Aproveite para comer algo enquanto os dados são transferidos…

Vamos preparar a nova partição:

# vi /mnt/crypt/etc/fstab

Troque a partição de root atual por /dev/sdb1.

/dev/sdb1     /       ext3     noatime         0 1

Edite também seu gerenciador de inicialização, no caso do grub, edite /boot/grub/menu.lst.

kernel /vmlinuz root=/dev/sda3

Troque pelos valores da sua nova partição (lembre-se estes são exemplos. Substitua pelas SUAS partições).

kernel /vmlinuz root=/dev/sdb1

# reboot

Depois da inicialização, verifique se realmente está na nova partição:

# mount | grep ‘on / type’

Deve apresentar a partição de backup, no meu caso /dev/sdb1.

Preparando as partições root e swap a criptografar

Agora vamos preparar a "antiga" root. O primeiro passo é encher
toda a partição com ‘lixo’ de forma que um possível atacante não tenha
como saber o quanto de dados foram escritos partição:

# shred -vn 1 /dev/sda3

Agora aproveite para dar uma cochilada, caminhar, ler ou espere bastante dependendo dos recursos da sua máquina.

Encriptar a partição swap

Digamos que sua partição swap seja /dev/sda2.

# cryptsetup -c blowfish -h sha256 -d /dev/urandom create swap /dev/sda2
# mkswap /dev/mapper/swap
# swapon /dev/mapper/swap

Agora vamos criar a nova partição root.

Criando a nova partição root

Você precisa de uma senha. Segura.
Bem Segura. Você pode gerar alguma senha aleatória a partir de algum
gerador de senhas aleatório. (veja apg, gpw ou visite
http://www.diceware.com/). Você pode escolher uma senha complexa e
anotar em um papel secretamente em seu poder. Quando memorizar queime
este papel.

# cryptsetup -y –cipher serpent-cbc-essiv:sha256 –key-size 256 luksFormat /dev/sda3
WARNING!
========
This will overwrite data on /dev/sda3 irrevocably.

Enter LUKS passphrase: (insira a senha)
Verify passphrase: (repita a senha)

Agora você pode abrir sua partição LUKS:

# cryptsetup luksOpen /dev/sda3 root
Enter LUKS passphrase:
key slot 0 unlocked.

A partir de agora sua partição de root passa a ser denominada /dev/mapper/root. Vamos criar um sistema de arquivos na mesma:

# /sbin/mkfs.ext3 -j -m 1 -O dir_index,filetype,sparse_super /dev/mapper/root

(espere vários minutos…)

mke2fs 1.35 (28-Feb-2004)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
36634624 inodes, 73258400 blocks
732584 blocks (1.00%) reserved for the super user
First data block=0
2236 block groups
32768 blocks per group, 32768 fragments per group
16384 inodes per group
Superblock backups stored on blocks:
       32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208,
       4096000, 7962624, 11239424, 20480000, 23887872, 71663616

Writing inode tables: done
Creating journal (8192 blocks): done
Writing superblocks and filesystem accounting information: done

This filesystem will be automatically checked every 39 mounts or
180 days, whichever comes first. Use tune2fs -c or -i to override.

Monte a agora a partição:

# mount -t ext3 /dev/mapper/root /mnt/crypt

Agora vamos transferir os dados da sua partição root temporária para a nova partição criptografada:

# cd /
# cp -avx / /mnt/crypt

(espere novamente bastante…)

E quando terminar:

# cd /mnt/crypt/dev
# MAKEDEV generic

Criando a imagem initramfs

A initramfs é um ramfs no qual um arquivo initramfs é
desempacotado antes que o kernel efetue tarefas tais como montar a
partição root. Este arquivo pode ser inserido junto com a imagem do
kernel, no momento da confecção do mesmo ou como um arquivo separado.

Para nossa initramfs precisamos do busybox. Busybox é um
conjunto de utilitários comuns em sistemas UNIX em um único e minúsculo
executável. Para usuários de Gentoo:

# mkdir /usr/local/src/build_initramfs
# ROOT="/usr/local/src/build_initramfs/" USE="-pam make-symlinks static" emerge -av busybox

Edite /etc/portage/savedconfig/sys-apps/busybox-<version>
e tenha certeza de que a linha CONFIG_BUSYBOX_EXEC_PATH está como
abaixo:

CONFIG_BUSYBOX_EXEC_PATH="/bin/busybox"

Senão altere e construa o busybox novamente com a USE savedconfig.

# ROOT="/usr/local/src/build_initramfs/" USE="-pam savedconfig make-symlinks static" emerge -av busybox
# cd /usr/local/src/build_initramfs
# rm -r {etc,usr,lib,lib64,var}

Usuários Debian ou outra distribuição devem baixar as fontes diretamente de http://www.busybox.net/.

# tar -xjvf busybox-<versão>
# cd busybox-<versão>
# make menuconfig

E selecione as opções conforme:

Vamos gerar um kmap (mapa do teclado):

# dumpkeys > default_keymap
# loadkeys br-abnt2
# /usr/local/src/build_initramfs/bin/busybox dumpkmap > br-abnt2-<ARCH>.bin

Ou, se você compilou as fontes do pacote oficial do busybox:

<caminho para as fontes do busybox>/busybox dumpkmap > br-abnt2-<ARCH>.bin

Como eu uso amd64 no lugar de ARCH inseri amd64 ficando br-abnt2-amd64.bin Se for i386, idem.

# loadkeys default_keymap

O arquivo init do initramfs

Quando você boota seu sistema, o
kernel irá extrair o initramfs para o rootfs e verificará se um arquivo
chamado "init" existe, e se encontrado o executará. O arquivo init no
nosso caso será responsável por decriptar e montar a partição root
quando então o resto do processo de boot será assumido pelo init da
partição root.

O init constante em http://gentoo-wiki.com/…Initramfs.27s_init não funciona em versões recentes do busybox. Assim você deve usar meu arquivo atualizado e disponibilizado em:

Preparando a initramfs

Baixe também o arquivo applets:

Se você compilou o busybox com o pacote do site oficial faça o seguinte:

Crie o diretório temporário para a initramfs:

# mkdir /usr/local/src/build_initramfs

E crie os links para o busybox:

# cd /path/to/busybox-<version>
# ./applets/install.sh /usr/local/src/build_initramfs –symlinks

Agora, independente de qual busybox esteja usando faça o seguinte:

Crie os diretórios necessários:

# cd /usr/local/src/build_initramfs
# mkdir {proc,sys,new-root,etc,dev}

Copie o script init:

# cp /path/to/init .
# chmod 755 init

Crie os dispositivos necessários:

# mknod –mode=0660 /usr/local/src/build_initramfs/dev/null c 1 3
# mknod –mode=0600 /usr/local/src/build_initramfs/dev/console c 5 1

Você precisa de um executável estático executável cryptsetup. Pode baixá-lo de:

# cp cryptsetup-<versão>-<arch>-pc-linux-gnu-static /usr/local/src/build_initramfs/sbin/cryptsetup
# chmod u+x /usr/local/src/build_initramfs/sbin/cryptsetup

Você pode incluir um arquivo com uma art ascii para ser
apresentado no momento do login, para um visual mais bonito. Salve em
/usr/local/src/build_initramfs/etc copie também o kmap que você criou
anteriormente e o applets em /usr/local/src/build_initramfs/etc.

Recompilando o kernel

Agora finalmente vamos criar a imagem
initramfs diretamente nas fontes do kernel. Tenha certeza de que a
fonte do seu kernel esteja em /usr/src/linux.

# rm -iv /usr/src/linux/usr/initramfs_data.cpio.gz
# cd /usr/local/src/build_initramfs
# find . | cpio –quiet -o -H newc | gzip -9 >/usr/src/linux/usr/initramfs_data.cpio.gz
# touch /usr/src/linux/usr/initramfs_data.cpio.gz

Tenha certeza que seu kernel está configurado conforme as opções apresentadas no início. Agora compile mais uma vez:

# mount /boot
# make && make modules modules_install install

Ou para Debian:

# make-kpkg –revision=crypt.1.0 kernel-image
# dpkg -i <novo-pacote-do-kernel>

Últimos passos

Edite o fstab da sua partição root encriptada para usar /dev/mapper/root.

# vi /mnt/crypt/etc/fstab

/dev/mapper/root        /         ext3    noatime       0 1

E finalmente edite o bootloader (grub):

title=Gentoo Linux 2.6.23
root (hd0,0)
kernel /vmlinuz root=/dev/sda3 ikmap=br-abnt2-amd64.bin

root é o dispositivo ordinário da sua partição encriptada e ikmap é o mapa do teclado.

Reinicie seu sistema e reze para que o prompt com a senha apareça…

Se deu tudo certo, é hora de cuidar das outras partições.

Encriptando as demais partições

Você pode efetuar o mesmo
procedimento de backup para a partição home ou outras, através do
comando cp -avx. Claro, a mídia de backup deve ser grande o suficiente
para que caibam as partições que deseja.

É preciso criar o mapper das demais partições tal qual fizemos
na partição root substituindo apenas o dispositivo da partição que
deseja criptografar.

# cryptsetup -y –cipher serpent-cbc-essiv:sha256 –key-size 256 luksFormat /dev/sda4

Para garantir mais segurança você pode usar uma senha diferente que a da partição root.

Edite o arquivo /etc/conf.d/cryptfs. Ele é bem simples e
auto-explicativo. Ele cuida da decriptação e encriptação das partições
na inicialização, exceto a partição root, que é cuidada pela initramfs.

swap=swap
source=’/dev/sda2′

target=home
source=’/dev/sda6′

Depois insira os novos dispositivos mapper na sua fstab tal qual a partição root.

/dev/mapper/root       /          ext3      noatime         0 1
/dev/mapper/swap       none       swap      sw              0 0
/dev/mapper/home       /home      ext3      noatime         0 2

Criando um cdrom bootável

Baixe a última versão do syslinux de:

# tar -xvjf syslinux-<versão>.tar.bz2

Crie um diretório para confeccionar seu cdrom:

# mkdir crypt-cd
# cp /boot/vmlinuz-<blablabla> crypt-cd
# cp /caminho/para/syslinux-<versao>/isolinux.bin crypt-cd/vmlinuz
# echo "DEFAULT /vmlinuz ro root=/dev/sda3" > crypt-cd/isolinux.cfg

Agora crie a imagem e queime seu cdrom:

# mkisofs -o crypt-cd.iso -b isolinux.bin -c boot.cat \
-no-emul-boot -boot-load-size 4 -boot-info-table \
-J -hide-rr-moved -R crypt-cd/
# cdrecord cryptcd.iso

No seu dia-a-dia você deve sempre bootar pelo cdrom. A partição boot é apenas para casos de emergência.


http://www.vivaolinux.com.br/artigos/verArtigo.php?codigo=7612

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s