dm-crypt (Português)/Encrypting an entire system (Português)
Os exemplos a seguir são cenários comuns de um sistema criptografado com dm-crypt. Eles explicam todas as adaptações que serão realizadas do processo de instalação. Todas as ferramentas necessárias estão disponíveis na imagem de instalação.
Se você deseja criptografar um sistema de arquivos não criptografado existente, consulte Criptografar um sistema de arquivos não criptografado existente.
Visão geral
dm-crypt se destaca, tanto em funcionalidades quanto em velocidade, quando o assunto é proteger o sistema de arquivos principal. Diferente da encriptação seletiva de sistemas de arquivos secundários, a criptografia de todo um sistema pode proteger informações como quais programas estão instalados, os nomes de usuários de todas as contas, e vetores comuns de vazamento de dados tais como locate e /var/log. E, é bem mais difícil fazer alterações em um sistema criptografado, exceto o gerenciador de boot e (geralmente) o kernel que não são criptografados.
Todos os cenários ilustrados a seguir compartilham as vantagens supracitadas, prós e contras que os diferenciam estão resumidos abaixo:
| Cenários | Vantagens | Desvantagens |
|---|---|---|
|
#LUKS em uma partição
Mostra uma configuração básica e direta para uma partição principal criptografada com LUKS. |
|
|
|
#LVM dentro do LUKS
Consegue flexibilidade no particionamento ao usar LVM dentro de uma partição criptografada com LUKS. |
|
|
|
#LUKS dentro do LVM
usa dm-crypt somente depois de configurar o LVM. |
|
|
|
#LUKS dentro do RAID de software
usa dm-crypt somente depois de configurar RAID. |
|
|
|
#dm-crypt plain
usa o modo plain (plano) do dm-crypt, sem cabeçalho do LUKS e suas opções para múltiplas chaves. |
|
|
|
#Partição de boot criptografada (GRUB)
Mostra como criptografar a partição de boot usando o gerenciador de boot GRUB. |
|
|
|
#Subvolumes do Btrfs com swap
Mostra como criptografar um sistema Btrfs, incluindo o diretório |
|
|
| #Raiz no ZFS |
Enquanto todos os cenários acima oferecem maior proteção contra ameaças externas do que somente criptografar sistemas de arquivos não raiz, eles também possuem uma desvantagem comum: qualquer usuário que possui a chave pode abrir todo o disco, e assim, acessar os dados de outro usuário. Se isto é uma preocupação, é possível fazer uma combinação de dispositivo de blocos e sistema de arquivos criptografados empilhados e adquirir as vantagens de ambos. Veja Criptografia de dados em repouso para lhe ajudar no planejamento.
Veja Dm-crypt/Preparando a unidade de armazenamento#Particionamento para uma visão geral das estratégias de particionamento usadas nos cenários.
Outra coisa a considerar é se deve usar uma partição swap criptografada e de qual forma. Veja dm-crypt/Swap criptografada para alternativas.
Se você antecipa a proteção de dados do sistema não somente contra roubo físico, como também contra adulteração lógica, veja dm-crypt/Especialidades#Protegendo a partição de boot não criptografada para possibilidades futuras após seguir um dos cenários.
Para SSDs, você pode considerar habilitar suporte ao TRIM, mas esteja ciente que, isto tem potenciais problemas de segurança. Veja dm-crypt/Especialidades#Suporte para descarte/TRIM para unidades de estado sólido (SSD) para mais informações.
- Em qualquer cenário, nunca diretamente repare um volume criptografado com ferramentas de reparação de sistema de arquivos como fsck, ou isto destruirá qualquer chance de recuperar a chave usada para abrir seus arquivos. Tais ferramentas devem ser usadas no dispositivo desbloqueado (aberto).
- Para o formato LUKS2:
- O suporte do GRUB para LUKS2 é limitado; veja GRUB#/boot criptografado para detalhes. Use LUKS1 (
cryptsetup luksFormat --type luks1) para partições que o GRUB precisará desbloquear. - O formato LUKS2 tem um alto uso de RAM por design, com padrão de 1 GB por mapeador criptografado. Máquinas com pouca RAM e/ou múltiplas partições LUKS2 desbloqueadas em paralelo podem apresentar erro na inicialização. Veja a opção
--pbkdf-memorypara controlar o uso de memória [1].
- O suporte do GRUB para LUKS2 é limitado; veja GRUB#/boot criptografado para detalhes. Use LUKS1 (
LUKS em uma partição
Este exemplo demonstra um sistema criptografado com dm-crypt + LUKS em uma partição:
+--------------------+-------------------------------+-----------------------+ | Partição de boot | Sistema criptografado com LUKS2 | Espaço livre opcional | | | partição | para outras partições | | | | | | /boot | / | | | | | | | | /dev/mapper/raiz | | | |-------------------------------| | | /dev/sda1 | /dev/sda2 | | +--------------------+-------------------------------+-----------------------+
Os primeiros passos podem ser executados imediatamente após iniciar a imagem de instalação do Arch Linux.
Preparando o disco
Antes de criar qualquer partição, você deveria saber a importância e também métodos de como apagar o disco com segurança, descritos em dm-crypt/Preparando a unidade de armazenamento.
Crie as partições necessárias, ao menos uma para / (exemplo /dev/sda2) e /boot (/dev/sda1). Veja Particionamento.
Preparando partições que não são de boot
Os comandos a seguir criam e montam a partição raiz criptografada. Eles correspondem ao detalhado procedimento descrito em dm-crypt/Criptografando um sistema de arquivos não raiz#Partição (que, apesar do título, pode ser aplicado a partições raiz, contanto que mkinitcpio e o gerenciador de boot sejam corretamente configurados). Se você deseja usar opções de encriptação que não são padrão (exemplo, cifras criptográficas, tamanho da chave), veja as opções de encriptação antes de executar o primeiro comando. Para obter informações sobre como alterar o tamanho do setor padrão, veja dm-crypt/Device encryption#Encryption options for LUKS mode.
# cryptsetup -y -v luksFormat /dev/sda2 # cryptsetup open /dev/sda2 raiz # mkfs.ext4 /dev/mapper/raiz # mount /dev/mapper/root /mnt
Verifique se o mapeamento funcionou como esperado:
# umount /mnt # cryptsetup close raiz # cryptsetup open /dev/sda2 raiz # mount /dev/mapper/raiz /mnt
Se você criou partições separadas (exemplo, /home), estes passos têm que ser adaptados e repetidos para todos eles, exceto para /boot. Veja dm-crypt/Criptografando um sistema de arquivos não raiz#Desbloqueio e montagem automatizados para como manusear partições adicionais na inicialização.
Note que cada dispositivo de bloco precisa de sua própria senha. Isto pode ser inconveniente, por ser necessário inserir senhas separadas durante a inicialização. Uma alternativa é usar uma keyfile guardada na partição do sistema para desbloquear a partição separada por meio do crypttab. Veja dm-crypt/Encriptação de dispositivo#Formatando uma partição com LUKS e uma keyfile para instruções.
Preparando a partição de boot
O que você vai precisar fazer é uma partição para /boot não criptografada, que é necessária pelo sistema. Para uma partição ordinária em sistemas BIOS, por exemplo, execute:
# mkfs.ext4 /dev/sda1
Ou para uma Partição de sistema EFI em sistemas UEFI:
# mkfs.fat -F32 /dev/sda1
Depois crie o diretório e monte a partição:
# mount --mkdir /dev/sda1 /mnt/boot
Mountando os dispositivos
no Guia de instalação#Montar os sistemas de arquivos você vai precisar montar os dispositivos criptografados, não as partições. Claro /boot, que não é criptografado, ainda precisará ser montado diretamente.
Configurando o mkinitcpio
Adicione os hooks keyboard, keymap e encrypt em mkinitcpio.conf. Se deseja padrão de teclado US, você pode omitir o hook keymap.
HOOKS=(base udev autodetect keyboard keymap consolefont modconf block encrypt filesystems fsck)
Se está usando o hook sd-encrypt com o initramfs baseado no systemd, o seguinte precisa ser definido ao invês:
HOOKS=(base systemd autodetect keyboard sd-vconsole modconf block sd-encrypt filesystems fsck)
Gere novamente o initramfs depois de salvar as alterações. Veja dm-crypt/Configuração do sistema#mkinitcpio para detalhes e outros hooks que você pode precisar.
Configurando o gerenciador de boot
Para desbloquear a partição raiz criptografada na inicialização, os seguintes parâmetros do kernel devem ser adicionados ao gerenciador de boot:
cryptdevice=UUID=UUID-da-partição-raiz:raiz root=/dev/mapper/raiz
Se está usando o hook sd-encrypt, o seguinte precisa ser definido ao invês:
rd.luks.name=UUID-da-partição-raiz=raiz root=/dev/mapper/raiz
Veja dm-crypt/Configuração do sistema#Parâmetros do Kernel para detalhes.
O UUID-da-partição-raiz refere-se ao UUID da partição raiz, nesse caso /dev/sda2. Veja Nomeação persistente de dispositivo de bloco para detalhes.
LVM dentro do LUKS
O método mais direto é configurar o LVM em cima da partição criptografada, e não o contrário. Tecnicamente o LVM está dentro de um grande dispositivo de bloco criptografado. Em razão disso, o LVM não é visível até que o dispositivo de bloco seja aberto e o volume estruturado abaixo seja escaneado e montado durante a inicialização.
O design do disco neste exemplo é::
+-----------------------------------------------------------------------+ +------------------+ | volume lógico 1 | volume lógico 2 | volume Lógico 3 | | Partição de boot | | | | | | | | [SWAP] | / | /home | | /boot | | | | | | | | /dev/MeuGrupoVol/swap | /dev/MeuGrupoVol/raiz | /dev/MeuGrupoVol/home | | (pode ser | |_ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ _| | em outro | | | | dispositivo) | | Partição criptografada com LUKS2 | | | | /dev/sda1 | | /dev/sdb1 | +-----------------------------------------------------------------------+ +------------------+
encrypt, você não poderá utilizar volumes lógicos espalhados em múltiplos discos; use o sd-encrypt ou veja dm-crypt/Especialidades#Modificando o hook encrypt para múltiplas partições.- Instruções em dm-crypt/Especialidades#Sistema criptografado usando um cabeçalho LUKS desanexado para usar um cabeçalho do LUKS em um dispositivo USB, e assim conseguindo autentificação de dois fatores com este método.
- Instruções em dm-crypt/Especificidades#/boot criptografado e um cabeçalho do LUKS desanexado dentro de um USB para usar um cabeçalho do LUKS, partição
/bootcriptografada, e keyfile criptografada tudo em um dispositivo USB.
Preparando o disco
Antes de criar qualquer partição, você deveria saber a importância e também métodos de como apagar o disco com segurança, descritos em dm-crypt/Preparando a unidade de armazenamento.
Crie uma partição que será montada em /boot com o tamanho de 200 MiB ou mais.
/boot.Crie uma partição que depois irá conter o container criptografado.
Crie o container criptografado com LUKS na partição do sistema. Digite a senha escolhida duas vezes.
# cryptsetup luksFormat /dev/sda1
Para mais informações sobre as opções disponíveis do cryptsetup veja as opções de encriptação antes de executar o comando acima.
Abra o container:
# cryptsetup open /dev/sda1 cryptlvm
O container estará disponível em /dev/mapper/cryptlvm.
Preparando os volumes lógicos
Crie um volume físico em cima do container LUKS aberto:
# pvcreate /dev/mapper/cryptlvm
Crie um grupo de volumes (neste exemplo chamado de MeuGrupoVol, mas pode ser o que você quiser) e adicione o volume físico criado anteriormente a ele:
# vgcreate MeuGrupoVol /dev/mapper/cryptlvm
Crie todos os seus volumes lógicos no grupo de volumes:
# lvcreate -L 8G MeuGrupoVol -n swap # lvcreate -L 32G MeuGrupoVol -n raiz # lvcreate -l 100%FREE MeuGrupoVol -n home
Formate cada volume lógico para os sistemas de arquivos desejados:
# mkfs.ext4 /dev/MeuGrupoVol/raiz # mkfs.ext4 /dev/MeuGrupoVol/home # mkswap /dev/MeuGrupoVol/swap
Monte eles:
# mount /dev/MeuGrupoVol/raiz /mnt # mount --mkdir /dev/MeuGrupoVol/home /mnt/home # swapon /dev/MeuGrupoVol/swap
Preparando a partição de inicialização
O gerenciador de boot carrega o kernel, initramfs, e seus arquivos de configuração do diretório /boot. Qualquer sistema de arquivos em um disco que pode ser lido pelo gerenciador de boot é elegível para uso.
Coloque um sistema de arquivos na partição escolhida como /boot:
# mkfs.ext4 /dev/sdb1
/boot em uma Partição de sistema EFI a formatação recomendada é
# mkfs.fat -F32 /dev/sdb1
Monte a partição para /mnt/boot:
# mount --mkdir /dev/sdb1 /mnt/boot
Configurando o mkinitcpio
Certifiique-se de que o pacote lvm2 está instalado e adicione os hooks keyboard, keymap, encrypt e lvm2 em mkinitcpio.conf:
HOOKS=(base udev autodetect keyboard keymap consolefont modconf block encrypt lvm2 filesystems fsck)
Se está usando o hook sd-encrypt com o initramfs baseado no systemd, o seguinte precisa ser definido ao invês:
HOOKS=(base systemd autodetect keyboard sd-vconsole modconf block sd-encrypt lvm2 filesystems fsck)
Gere novamente o initramfs depois de salvar as alterações. Veja dm-crypt/Configuração do sistema#mkinitcpio para detalhes e outros hooks que você pode precisar.
Configurando o gerenciador de boot
Para desbloquear a partição raiz criptografada na inicialização, os seguintes parâmetros do kernel devem ser adicionados ao gerenciador de boot:
cryptdevice=UUID=UUID-do-dispositivo:cryptlvm root=/dev/MeuGrupoVol/raiz
Se você está usando o hook sd-encrypt, o seguinte precisa ser definido:
rd.luks.name=UUID-do-dispositivo=cryptlvm root=/dev/MeuGrupoVol/raiz
O UUID-do-dispositivo refere-se ao UUID da partição raiz, nesse caso /dev/sda1. Veja Nomeação persistente de dispositivo de bloco para mais detalhes.
Se está usando dracut, você pode precisar usar uma extensiva lista de parâmetros, tente:
kernel_cmdline="rd.luks.uuid=luks-UUID-do-dispositivo rd.lvm.lv=MeuGrupoVol/root rd.lvm.lv=MeuGrupoVol/swap root=/dev/mapper/MeuGrupoVol-root rootfstype=ext4 rootflags=rw,relatime"
Veja dm-crypt/Configuração do sistema#Gerenciador de boot para mais informação sobre.
LUKS dentro do LVM
Você deve configurar os volumes do LVM primeiro antes de usá-los como base para as partições criptografadas. Desta maneira, é possível fazer uma mistura de volumes/partições que são criptografadas ou não.
O texto a seguir exemplifica uma configuração do LUKS dentro do LVM que também faz uso de uma keyfile para o volume lógico /home e volumes temporários criptografados para /tmp e /swap. O último é desejável caso se preocupe com segurança, devido a evitar que dados temporários sensíveis sobrevivam durante a inicialização do sistema. Se tem experiência com LVM, você vai ser capaz de ignorar/trocar alguns dos passos relacionados com ele e outras coisas específicas de acordo com sua vontade.
Se quer usar volumes lógicos espalhados por múltiplos discos que já foram configurados, ou expandir o /home (ou qualquer outro volume), um dos jeitos de como fazer isto é descrito em dm-crypt/Especialidades#Expandindo LVM em múltiplos discos. Vale notar que o container criptografado com LUKS precisa ser redimensionado também.
Preparando o disco
Esquema de particionamento:
+------------------+------------------------------------------------------------------------------------------------+ | Partição de boot | Volume criptografado com o | Volume criptografado com LUKS2 | Volume criptografado com LUKS2 | | | modo plain do dm-crypt | | | | | | | | | /boot | [SWAP] | / | /home | | | | | | | | /dev/mapper/swap | /dev/mapper/raiz | /dev/mapper/home | | |_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ | | | Volume lógico 1 | Volume lógico 2 | Volume lógico 3 | | | /dev/MeuGrupoVol/cryptswap | /dev/MeuGrupoVol/cryptraiz | /dev/MeuGrupoVol/crypthome | | |_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ | | /dev/sda1 | /dev/sda2 | +------------------+------------------------------------------------------------------------------------------------+
Randomize /dev/sda2 de acordo com dm-crypt/Preparando a unidade de armazenamento#dm-crypt limpa o disco vazio ou partição.
Preparando os volumes lógicos
# pvcreate /dev/sda2 # vgcreate MeuGrupoVol /dev/sda2 # lvcreate -L 32G -n raiz MeuGrupoVol # lvcreate -L 500M -n cryptswap MeuGrupoVol # lvcreate -L 500M -n crypttmp MeuGrupoVol # lvcreate -l 100%FREE -n crypthome MeuGrupoVol
# cryptsetup luksFormat /dev/MeuGrupoVol/cryptraiz # cryptsetup open /dev/MeuGrupoVol/cryptraiz raiz # mkfs.ext4 /dev/mapper/raiz # mount /dev/mapper/raiz /mnt
Mais informações sobre opções de encriptação podem ser encontradas em dm-crypt/Encriptação de dispositivo#Opções de encriptação para o modo LUKS.
Note que /home será criptografada em #Criptografando o volume lógico /home.
open vai possibilitar a execução de comandos para mostrar volumes do LVM.Preparando a partição de boot
# dd if=/dev/zero of=/dev/sda1 bs=1M status=progress # mkfs.ext4 /dev/sda1 # mount --mkdir /dev/sda1 /mnt/boot
Configurando o mkinitcpio
Certifique-se de que o pacote lvm2 está instalado, e adicione os hooks keyboard, lvm2 e encrypt em mkinitcpio.conf:
HOOKS=(base udev autodetect keyboard keymap consolefont modconf block lvm2 encrypt filesystems fsck)
Se está usando o hook sd-encrypt com o initramfs baseado no systemd, o seguinte precisa ser definido ao invês:
HOOKS=(base systemd autodetect keyboard sd-vconsole modconf block sd-encrypt lvm2 filesystems fsck)
Gere novamente o initramfs depois de salvar as alterações. Veja dm-crypt/Configuração do sistema#mkinitcpio para detalhes e outros hooks que você pode precisar.
Configurando o gerenciador de boot
Para abrir a partição raiz criptografada na inicialização, os seguintes parâmetros do kernel precisam ser adicionados ao gerenciador de boot:
cryptdevice=UUID=UUID-do-dispositivo:raiz root=/dev/mapper/raiz
Se está usando o hook sd-encrypt, o seguinte precisa ser definido:
rd.luks.name=UUID-do-dispositivo=raiz root=/dev/mapper/raiz
O UUID-do-dispositivo refere-se ao UUID do /dev/MeuGrupoVol/cryptraiz. Veja Nomeação persistente de dispositivo de bloco para detalhes.
Veja dm-crypt/Configuração do sistema#Parâmetros do Kernel para detalhes.
Configurando o fstab e crypttab
Ambas as entradas do crypttab e fstab são necessárias para abrir o dispositivo e montar os sistemas de arquivos, respectivamente. As seguintes linhas irão criptografar os sistemas de arquivos temporários a cada inicialização:
/etc/crypttab
swap /dev/MeuGrupoVol/cryptswap /dev/urandom swap,cipher=aes-xts-plain64,size=256 tmp /dev/MeuGrupoVol/crypttmp /dev/urandom tmp,cipher=aes-xts-plain64,size=256
/etc/fstab
/dev/mapper/raiz / ext4 defaults 0 1 /dev/sda1 /boot ext4 defaults 0 2 /dev/mapper/tmp /tmp tmpfs defaults 0 0 /dev/mapper/swap none swap sw 0 0
Criptografando o volume lógico /home
Devido a este cenário usar LVM como mapeador primário e dm-crypt como secundário, cada volume lógico precisa ser criptografado separadamente. Apesar disso, diferente dos sistemas de arquivos temporários que foram configurados acima para serem voláteis, o volume lógico para /home vai ser persistente. O seguinte assume que você reiniciou o seu sistema criptografado, se você não fez isto, precisará adaptar os caminhos.
Para não digitar uma segunda senha na inicialização, uma keyfile é criada:
# mkdir -m 700 /etc/luks-keys # dd if=/dev/random of=/etc/luks-keys/home bs=1 count=256 status=progress
O volume lógico é criptografado com:
# cryptsetup luksFormat -v /dev/MeuGrupoVol/crypthome /etc/luks-keys/home # cryptsetup -d /etc/luks-keys/home open /dev/MeuGrupoVol/crypthome home # mkfs.ext4 /dev/mapper/home # mount /dev/mapper/home /home
A montagem dos volumes criptografados é feita tanto no crypttab como no fstab:
/etc/crypttab
home /dev/MeuGrupoVol/crypthome /etc/luks-keys/home
/etc/fstab
/dev/mapper/home /home ext4 defaults 0 2
LUKS dentro do RAID de software
Este exemplo é baseado em uma configuração real para um notebook empresarial equipado com dois SSDs de tamanho igual, e um HDD adicional para guardar dados. O resultado é uma encriptação total de disco com LUKS1 (incluindo /boot) para todos as unidades de armazenamento, Os SSDs em um arranjo RAID0, e são usadas keyfiles para abrir todos os dispositivos criptografados, depois que o GRUB recebe a senha correta na inicialização.
Esta configuração usa um esquema de partições muito simples, com as unidades de armazenamento RAID sendo montadas em / (sem partição /boot separada), e o HDD montado em /data.
Por favor note que backups regulares são muito importantes. Se qualquer um dos SSDs falharem, os dados contidos no arranjo RAID serão praticamente impossíveis de recuperar. Você pode querer um diferente nível de RAID se a tolerância a falhas é considerada importante.
A encriptação não é negável nesta configuração.
Para as instruções abaixo, os seguintes dispositivos de bloco são usados:
/dev/sda = primeiro SSD /dev/sdb = segundo SSD /dev/sdc = HDD
+---------------+----------------+-----------------------+ +---------------+----------------+-----------------------+ +---------------------+ | Partição de | Partição de | Volume LUKS1 | | Partição de | Partição de | Volume LUKS1 | | volume LUKS2 | | inicialização | sistema EFI | criptografado | | inicialização | sistema EFI | criptografado | | criptografado | | de BIOS | | | | de BIOS | | | | | | | | | | | | | | | | | /efi | / | | | /efi | / | | /data | | | | | | | | | | | | | | /dev/mapper/raiz | | | | /dev/mapper/raiz | | | | +----------------+-----------------------+ | +----------------+-----------------------+ | | | | arranjo RAID1 | arranjo RAID0 | | | arranjo RAID1 | arranjo RAID0 | | | | | (parte 1 de 2) | (parte 1 de 2) | | | (parte 2 de 2) | (parte 2 de 2) | | | | | | | | | | | | | | | /dev/md/ESP | /dev/md/raiz | | | /dev/md/ESP | /dev/md/raiz | |/dev/mapper/data| | +----------------+-----------------------+ | |+---------------+-----------------------+ +---------------------+ | /dev/sda1 | /dev/sda2 | /dev/sda3 | | /dev/sdb1 | /dev/sdb2 | /dev/sdb3 | | /dev/sdc1 | +---------------+----------------+-----------------------+ +---------------+----------------+-----------------------+ +---------------------+
Certifique-se de substituí-los pelas designações de dispositivo apropriadas para sua configuração, pois podem ser diferentes.
Preparando os discos
Antes de criar qualquer partição, você deve se informar sobre a importância e também métodos de como apagar o disco com segurança, descritos em dm-crypt/Preparando a unidade de armazenamento.
Para sistemas BIOS com GPT, crie uma Partição de inicialização de BIOS com o tamanho de 1 MiB para o GRUB poder utilizá-lo no segundo estágio da inicialização da BIOS. Não monte a partição. Para sistemas BIOS/MBR isto não é necessário.
Para sistemas UEFI crie uma Partição de sistema EFI com um tamanho apropriado, ela mais tarde será montada em /efi.
No restante do espaço disponível no dispositivo, crie uma partição (/dev/sda3 neste exemplo) "Linux RAID". Coloque o ID do tipo da partição: fd para MBR ou GUID A19D880F-05FC-4D3B-A006-743F0F84911E para GPT.
Uma vez que as partições forem criadas em /dev/sda, os seguintes comandos podem ser usados para clonar elas para /dev/sdb.
# sfdisk -d /dev/sda > sda.dump # sfdisk /dev/sdb < sda.dump
O HDD é preparado com um única partição Linux (/dev/sdc1) para todo o disco.
Fazendo o arranjo RAID
Crie o arranjo RAID para os SSDs.
- Todas as partes de uma partição de sistema EFI de arranjo RAID devem ser individualmente usáveis, isto significa que ela pode ser somente colocada em um arranjo RAID1.
- O superbloco RAID deve ser colocado no fim da partição de sistema EFI usando
--metadata=1.0, de outro modo, o firmware não conseguirá acessar a partição.
# mdadm --create --verbose --level=1 --metadata=1.0 --raid-devices=2 /dev/md/ESP /dev/sda2 /dev/sdb2
Este exemplo utiliza RAID0 para a raiz, você pode desejar substituir para um nível diferente baseado em suas preferências ou necessidades.
# mdadm --create --verbose --level=0 --metadata=1.2 --raid-devices=2 /dev/md/raiz /dev/sda3 /dev/sdb3
Preparando os dispositivos de bloco
Como explicado em dm-crypt/Preparando a unidade de armazenamento, os dispositivos são apagados com dados randômicos utilizando /dev/zero e um dispositivo criptografado com uma chave randômica. Alternativamente, você pode usar dd com /dev/random ou /dev/urandom, apesar que será muito mais lento.
# cryptsetup open --type plain /dev/md/raiz container --key-file /dev/random # dd if=/dev/zero of=/dev/mapper/container bs=1M status=progress # cryptsetup close container
e faça o mesmo para o HDD (/dev/sdc1 neste exemplo).
Configure a criptografia para /dev/md/raiz:
--type luks1) nas partições que o GRUB precisará acessar.# cryptsetup -y -v luksFormat --type luks1 /dev/md/raiz # cryptsetup open /dev/md/raiz raiz # mkfs.ext4 /dev/mapper/raiz # mount /dev/mapper/raiz /mnt
E faça o mesmo para o HDD:
# cryptsetup -y -v luksFormat /dev/sdc1 # cryptsetup open /dev/sdc1 data # mkfs.ext4 /dev/mapper/data # mount --mkdir /dev/mapper/data /mnt/data
Para sistemas UEFI, defina a ESP (partição de sistema EFI):
# mkfs.fat -F32 /dev/md/ESP # mount --mkdir /dev/md/ESP /mnt/efi
Configurando o GRUB
Configure GRUB para o sistema criptogrado com LUKS1, editando /etc/default/grub com o seguinte:
GRUB_CMDLINE_LINUX="cryptdevice=/dev/md/raiz:raiz" GRUB_ENABLE_CRYPTODISK=y
Se você tiver um teclado USB em um sistema mais recente, habilite o suporte a USB legado no firmware ou adicione o seguinte a /etc/default/grub:
GRUB_TERMINAL_INPUT="usb_keyboard"
GRUB_PRELOAD_MODULES="usb usb_keyboard ohci uhci ehci"
Caso contrário, talvez você não consiga usar o teclado no prompt do LUKS.
Veja dm-crypt/Configuração do sistema#Parâmetros do Kernel e GRUB#/boot criptografado para detalhes.
Complete a instalação do GRUB para ambos os SSDs (em realidade, instalando somente em /dev/sda irá funcionar).
# grub-install --target=i386-pc /dev/sda # grub-install --target=i386-pc /dev/sdb # grub-install --target=x86_64-efi --efi-directory=/efi --bootloader-id=GRUB # grub-mkconfig -o /boot/grub/grub.cfg
Criando as keyfiles
Os próximos passos evitarão que você digite a senha duas vezes quando você inicializar o sistema (uma vez quando o grub pede ela para abrir o dispositivo LUKS1, outra quando o mkinitcpio assume o controle do sistema). Isto é feito ao criar uma keyfile e adicionando ela na imagem intramfs, fazendo com que o hook encrypt abra o dispositivo raiz. Veja dm-crypt/Encriptação de dispositivo#Com uma keyfile no initramfs para detalhes.
- Crie a keyfile e adicione a chave para
/dev/md/raiz. - Crie outra keyfile para o HDD (
/dev/sdc1) para que ele seja decriptografado na inicialização. Para conveniência, deixe a senha criada acima em um lugar onde você consiga recuperar facilmente se precisar. Edite o/etc/crypttabpara decriptografar o HDD na inicialização. Veja Dm-crypt/Configuração do sistema#Desbloqueando com uma keyfile.
Configurando o sistema
Edite o fstab para montar os dispositivos de bloco raiz e data e o ESP:
/dev/mapper/raiz / ext4 rw,noatime 0 1 /dev/mapper/data /data ext4 defaults 0 2 /dev/md/ESP /efi vfat rw,relatime,codepage=437,iocharset=iso8859-1,shortname=mixed,utf8,tz=UTC,errors=remount-ro 0 2
Salve a configuração do RAID:
# mdadm --detail --scan >> /etc/mdadm.conf
Edite o mkinitcpio.conf e inclua sua keyfile, também coloque os hooks apropriados:
FILES=(/crypto_keyfile.bin) HOOKS=(base udev autodetect keyboard keymap consolefont modconf block mdadm_udev encrypt filesystems fsck)
Veja dm-crypt/Configuração do sistema#mkinitcpio para detalhes.
dm-crypt plain
Diferente do LUKS, o modo plain do dm-crypt não precisa de um cabeçalho no dispositivo criptografado: Este cenário explora isso para configurar um sistema em uma partição não criptografada, o disco criptografado não será diferenciável de um disco cheio de dados randômicos, isto possibilita a criptografia negável. Veja também wikipedia:Disk encryption#Full disk encryption.
Se a encriptação total de disco não é necessária, os métodos usando LUKS descritos nas seções acima são mais recomendados, tanto para a encriptação de sistema quanto partições. Funcionalidades do LUKS como gerenciamento de chaves com múltiplas senhas/keyfiles ou re-criptografar um dispositivo prontamente não estão disponiveis com o modo plain.
O modo plain pode ser mais resiliente a danos que o LUKS, devido a não depender de um chave mestre de encriptação, que se danificada resulta em falhas. No entanto, usar esse modo requer mais configuração manual de opções de encriptação para se chegar a mesma força criptográfica. Veja também Criptografia de dados em repouso#Metadados criptográficos. O uso desse modo também pode ser considerado se está preocupado com os problemas explicados em dm-crypt/Especialidades#Suporte a discard/TRIM para unidades de estado sólido (SSD).
-
modo LUKS do dm-crypt com um cabeçalho desanexado, usando a opção
--header. Este método não pode ser usado com o hook encrypt padrão, mas sim com um modificado. - tcplay, que oferece a encriptação sem cabeçalho mas com a função PBKDF2.
O cenário usa dois pendrives USB:
- um para o dispositivo de boot, que permite guardar as opções necessárias para abrir/desbloquear o dispositivo criptografado com o modo plain nas configurações do gerenciador de boot, desde que digitar eles a cada inicialização deve possivelemente resultar em erros;
- outro para a keyfile (arquivo chave), assumindo que esta está guardada em bits normais, o atacante desatento pode conseguir o pendrive com ela e pensar que a keyfile é um dado randômico ao invês de ser visível como um arquivo normal. Veja também Segurança por obscurantismo, siga dm-crypt/Encriptação de dispositivo#Keyfiles para prepará-la.
O exemplo de particionamento é:
+-----------------------+-----------------------+-----------------------+ +----------------+ +---------------+ | Volume lógico 1 | Volume lógico 2 | Volume lógico 3 | | Dispositivo de | | Lugar onde a | | | | | | boot | | keyfile será | | | | | | | | guardada (não | | / | [SWAP] | /home | | /boot | | particionada | | | | | | | | no exemplo) | | | | | | | | | | /dev/MeuVolGrupo/raiz | /dev/MeuVolGrupo/swap | /dev/MeuVolGrupo/home | | /dev/sdb1 | | /dev/sdc | |-------------------------+----------------------+----------------------| |----------------| |---------------| | O disco /dev/sda é criptografado com o modo plain e usa LVM | | Pendrive 1 | | Pendrive 2 | +-----------------------------------------------------------------------+ +----------------+ +---------------+
- É possível usar somente um pendrive:
- Ao colocar a chave em outra partição (por exemplo, /dev/sdb2).
- Ao copiar a keyfile para o initramfs diretamente. Por exemplo, uma keyfile é copiada para a imagem initramfs ao colocar
FILES=(/etc/keyfile)em/etc/mkinitcpio.conf. Para fazer o hookencryptler a keyfile na imagem initramfs, use o prefixorootfs:antes do nome do arquivo, exemplocryptkey=rootfs:/etc/keyfile.
- Outra opção é usar uma senha com uma boa entropia.
Preparando o disco
É vital que o dispositivo mapeado tenha dados randômicos. Em particular nesse cenário.
Veja dm-crypt/Preparando a unidade de armazenamento e dm-crypt/Preparando a unidade de armazenamento#Métodos específicos do dm-crypt
Preparando a partição que não é de boot
Veja dm-crypt/Encriptação de dispositivo#Opções de encriptação para o modo plain para detalhes.
Usando o dispositivo /dev/sda, com a cifra aes-xts, tamanho de chave de 512 bit e uma keyfile, temos as seguintes opções para esse cenário:
# cryptsetup --cipher=aes-xts-plain64 --offset=0 --key-file=/dev/sdc --key-size=512 open --type plain /dev/sda cryptlvm
Diferente da encriptação com LUKS, o comando acima deve ser executado completamente toda vez que o mapeamento precisa ser restabelecido, então é importante lembrar da cifra e detalhes da keyfile.
Podemos agora checar se a entrada de mapeamento foi feita para /dev/mapper/cryptlvm:
# fdisk -l
Agora, configure os volumes lógicos do Volumes lógicos não são exibidos no dispositivo mapeado. Veja Instalar Arch Linux no LVM para maiores detalhes:
# pvcreate /dev/mapper/cryptlvm # vgcreate MeuVolGrupo /dev/mapper/cryptlvm # lvcreate -L 32G MeuVolGrupo -n raiz # lvcreate -L 10G MeuVolGrupo -n swap # lvcreate -l 100%FREE MeuVolGrupo -n home
Formate e monte eles além de ativar a swap. Veja Sistemas de arquivos#Criar um sistema de arquivos para mais detalhes:
# mkfs.ext4 /dev/MeuVolGrupo/raiz # mkfs.ext4 /dev/MeuVolGrupo/home # mount /dev/MeuVolGrupo/raiz /mnt # mount --mkdir /dev/MeuVolGrupo/home /mnt/home # mkswap /dev/MeuVolGrupo/swap # swapon /dev/MeuVolGrupo/swap
Preparando a partição de boot
A partição /boot pode ser instalada na partição vfat de um pendrive, se necessário. Mas se o particionamento manual é desejado, criar uma partição de 200 MiB é necessário. Crie a partição usando uma ferramenta de particionamento de sua escolha.
Coloque um sistema de arquivos na partição /boot:
# mkfs.fat -F32 /dev/sdb1 # mount --mkdir /dev/sdb1 /mnt/boot
Configurando mkinitcpio
Certifique-se de que o pacote lvm2 está instalado e adicione os hooks keyboard, keymap, encrypt e lvm2 no mkinitcpio.conf:
HOOKS=(base udev autodetect keyboard keymap consolefont modconf block encrypt lvm2 filesystems fsck)
Gere novamente o initramfs depois de salvar as alterações. Veja dm-crypt/Configuração do sistema#mkinitcpio para detalhes e outros hooks que você pode precisar.
Configurando o gerenciador de boot
Para inicializar a partição raiz criptografada, os seguintes parâmetros do kernel precisma ser definidos no gerenciador de boot (note que 64 é o número de bytes em 512 bits):
cryptdevice=/dev/disk/by-id/ID-do-sda:cryptlvm cryptkey=/dev/disk/by-id/ID-do-sdc:0:64 crypto=:aes-xts-plain64:512:0:
ID-do-disco significa o ID do disco referenciado. Veja Nomeação persistente de dispositivo de bloco para detalhes.
Veja dm-crypt/Configuração do sistema#Parâmetros do Kernel para mais detalhes e outros parâmetros que você pode precisar.
# grub-install --recheck /dev/sdb
Pós-instalação
Você pode remover os pendrives depois da inicialização. Já que a partição /boot não é normalmente necessária, a opção noauto pode ser adicionada na linha relevante em /etc/fstab:
/etc/fstab
# /dev/sdb1 /dev/sdb1 /boot vfat noauto,rw,noatime 0 2
No entanto, quando uma atualização é feita para o initramfs, kernel ou gerenciador de boot, é necessário que ela esteja montada. Como uma entrada no fstab já existe, ela pode ser montada simplesmente com:
# mount /boot
Partição de boot criptografada (GRUB)
Esta configuração utiliza o mesmo particionamento que a seção #LVM dentro do LUKS, com diferença que o GRUB é usado por ser capaz de inicializar de um volume lógico LVM e um /boot criptografado com LUKS1. Veja também GRUB#/boot criptografado.
O Particionamento deste exemplo é:
+--------------------+---------------------+-----------------------+-----------------------+-----------------------+ | Partição de | Partição de sistema | Volume Lógico 1 | volume lógico 2 | volume lógico 3 | | inicialização BIOS | EFI | | | | | | | | | | | | /efi | / | [SWAP] | /home | | | | | | | | | | /dev/MeuVolGrupo/raiz | /dev/MeuVolGrupo/swap | /dev/MeuVolGrupo/home | | /dev/sda1 | /dev/sda2 |-----------------------+-----------------------+-----------------------+ | não criptografado | não criptografado | /dev/sda3 criptografado usando LVM dentro do LUKS1 | +--------------------+---------------------+-----------------------------------------------------------------------+
- Todos os cenários são exemplos. É possível utilizar os conceitos de distintos cenários na sua instalação, claro, adaptando o que for necessário. Veja também uma variação desse cenário em #LVM dentro do LUKS.
- Você pode usar o script
cryptbootdo pacote cryptbootAUR para um gerenciamento simplificado da inicialização com partição de boot criptografada (montar, desmontar, atualizar pacotes) e como uma defesa contra o ataque Evil Maid com UEFI Secure Boot. Para mais detalhes e limitações veja a página do projeto cryptboot.
Preparando o disco
Antes de criar qualquer partição, você deve saber a importância e métodos de como apagar o disco com segurança, descrito em dm-crypt/Preparando a unidade de armazenamento.
Para sistemas BIOS/GPT crie uma partição de inicialização de BIOS com o tamanho de 1 MiB para que o GRUB guarde o segundo estágio da inicialização BIOS. não monte a partição. Para sistemas BIOS/MBR isto não é necessário.
Para sistemas UEFI crie uma partição de sistema EFI com tamanho apropriado, será montada em /efi.
Crie uma partição do tipo 8309, que mais tarde conterá o container criptografado para a LVM.
Crie o container criptografado com LUKS:
cryptsetup luksFormat --type luks1) para partições que o GRUB precisará desbloquear.# cryptsetup luksFormat --type luks1 /dev/sda3
Para mais informações sobre as opções do cryptsetup disponíveis, veja dm-crypt/Encriptação de dispositivo#Opções de encriptação para o modo LUKS antes do comando acima.
Seu particionamento deve ser similar a:
# gdisk -l /dev/sda
... Number Start (sector) End (sector) Size Code Name 1 2048 4095 1024.0 KiB EF02 BIOS boot partition 2 4096 1130495 550.0 MiB EF00 EFI System 3 1130496 68239360 32.0 GiB 8309 Linux LUKS
Abra o container:
# cryptsetup open /dev/sda3 cryptlvm
o container aberto agora está disponível em /dev/mapper/cryptlvm.
Preparando os volumes lógicos
Os volumes lógicos do LVM neste exemplo seguem o particionamento acima como o cenário #LVM dentro do LUKS. Siga #Preparando os volumes lógicos acima, ajuste o que desejar e precisar.
Se você planeja inicializar no modo UEFI, crie um ponto de montagem para partição de sistema EFI em /efi para compatibilidade com grub-install e monte:
# mount --mkdir /dev/sda2 /mnt/efi
Neste ponto, você deve ter as seguintes partições e volumes lógicos dentro de /mnt:
$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 200G 0 disk
├─sda1 8:1 0 1M 0 part
├─sda2 8:2 0 550M 0 part /mnt/efi
└─sda3 8:3 0 100G 0 part
└─cryptlvm 254:0 0 100G 0 crypt
├─MeuVolGrupo-swap 254:1 0 8G 0 lvm [SWAP]
├─MeuVolGrupo-root 254:2 0 32G 0 lvm /mnt
└─MeuVolGrupo-home 254:3 0 60G 0 lvm /mnt/home
Configurando o mkinitcpio
Certifique-se de que o pacote lvm2 está instalado, e adicione os hooks keyboard, keymap, encrypt e lvm2 no mkinitcpio.conf:
HOOKS=(base udev autodetect keyboard keymap consolefont modconf block encrypt lvm2 filesystems fsck)
Se está usando o hook sd-encrypt com o initramfs baseado no systemd, o seguinte precisa ser definido ao invês:
HOOKS=(base systemd autodetect keyboard sd-vconsole modconf block sd-encrypt lvm2 filesystems fsck)
Gere novamente o initramfs depois de salvar as alterações. Veja dm-crypt/Configuração do sistema#mkinitcpio para detalhes e outros hooks que você pode precisar.
Configurando o GRUB
Para permitir a inicialização, configure o GRUB para que ele consiga acessar o /boot que está dentro de uma partição criptografada com LUKS1:
/etc/default/grub
GRUB_ENABLE_CRYPTODISK=y
Defina os parâmetros do kernel, para que o initramfs possa abrir a partição raiz criptografada. Se for usar o hook encrypt:
/etc/default/grub
GRUB_CMDLINE_LINUX="... cryptdevice=UUID=UUID-do-dispositivo:cryptlvm ..."
Se for usar o hook sd-encrypt, o seguinte precisa ser definido:
/etc/default/grub
GRUB_CMDLINE_LINUX="... rd.luks.name=UUID-do-dipositivo=cryptlvm ..."
Veja dm-crypt/Configuração do sistema#Parâmetros do Kernel e GRUB#/boot criptografado para detalhes. UUID-do-dispositivo refere-se ao UUID de /dev/sda3 (a partição que tem o sistema de arquivos raiz contido no LVM). Veja Nomeação persistente de dispositivo de bloco.
Instale o GRUB na ESP montada para inicialização UEFI:
# grub-install --target=x86_64-efi --efi-directory=/efi --bootloader-id=GRUB --recheck
Instale o GRUB no disco para inicialização BIOS:
# grub-install --target=i386-pc --recheck /dev/sda
Gere o arquivo de configuração do GRUB:
# grub-mkconfig -o /boot/grub/grub.cfg
Se todos os comandos foram executados sem erros, GRUB deve solicitar a senha para abrir a partição /dev/sda3 na próxima inicialização.
Evite digitar a senha duas vezes
Apesar do GRUB solicitar a senha para abrir a partição criptografada com LUKS1, isso não é passado para o initramfs. Consequentemente, você vai precisa digitar a senha duas vezes: uma vez para o GRUB e outra para o initramfs.
Esta seção lida com uma configuração extra para digitar a senha somente uma vez, no GRUB. Para isso é utilizado uma keyfile dentro do initramfs.
Primeiro crie uma keyfile e a adicione como uma chave do LUKS:
# dd bs=512 count=4 if=/dev/random of=/root/cryptlvm.keyfile iflag=fullblock # chmod 000 /root/cryptlvm.keyfile # cryptsetup -v luksAddKey /dev/sda3 /root/cryptlvm.keyfile
Adicione a keyfile para a imagem do initramfs:
/etc/mkinitcpio.conf
FILES=(/root/cryptlvm.keyfile)
Crie novamente a imagem initramfs e proteja a keyfile dentro dela:
# chmod 600 /boot/initramfs-linux*
Defina o seguinte parâmetro do kernel para abrir a partição criptografada com a keyfile. Se está usando o hook encrypt:
GRUB_CMDLINE_LINUX="... cryptkey=rootfs:/root/cryptlvm.keyfile"
Ou, usando o hook sd-encrypt:
GRUB_CMDLINE_LINUX="... rd.luks.key=device-UUID=/root/cryptlvm.keyfile"
Se por algum motivo a keyfile falhar, systemd solicitará a senha para abrir e, em caso dela estar correta, continuar a inicialização.
/boot para proteger contra ameaças de adulteração offline (offline tampering threats), o hook mkinitcpio-chkcryptoboot têm sido desenvolvido para isso.Subvolumes do Btrfs com swap
O seguinte exemplo cria todo um sistema criptografado com LUKS1, simulando partições com subvolumes do Btrfs.
Ao usar UEFI, uma Partição de sistema EFI (ESP) é necessária. /boot pode estar em / e ser criptografada; no entanto, a ESP não pode ser criptografada. Neste exemplo, a ESP é /dev/sda1 e está montada em /efi. /boot está localizada na partição do sistema, /dev/sda2.
Desde que /boot reside na / criptografada com LUKS1, GRUB deve ser usado como o gerenciador de boot porque somente ele pode carregar os módulos para decriptografar /boot (exemplo, crypto.mod, cryptodisk.mod e luks.mod).
Também é mostrada uma partição swap criptografada.
+-----------------------+-------------------------+------------------+ | Partição de sistema | Partição do sistema | Partição swap | | EFI não criptografada | criptografada com LUKS1 | criptografada | | | | | | /efi | / | [SWAP] | | /dev/sda1 | /dev/sda2 | /dev/sda3 | +-----------------------+-------------------------+------------------+
Preparando o disco
Antes de criar qualquer partição, você deveria saber a importância e também métodos de como apagar o disco com segurança, descritos em dm-crypt/Preparando a unidade de armazenamento. Se você está usando UEFI crie uma partição de sistema EFI com o tamanho apropriado. Ela será montada em /efi. Se você vai criar uma partição swap criptografada, crie ela, mas não marque isso como swap, desde que ela será usada no modo plain do dm-crypt.
Crie as partições, ao menos uma para / (exemplo, /dev/sda2). Veja o artigo Particionamento.
Preparando a partição do sistema
Crie o container LUKS
cryptsetup luksFormat --type luks1) para partições que o GRUB precisará desbloquear.Siga dm-crypt/Encriptação de dispositivo#Criptografando dispositivos com o modo LUKS para configurar o /dev/sda2 para LUKS. Veja o dm-crypt/Encriptação de dispositivo#Opções de encriptação para o modo LUKS para uma lista de opções de encriptação.
Abra o container LUKS
Siga dm-crypt/Encriptação de dispositivo#Abrindo/Mapeando containers LUKS com o mapeador de dispositivos para abrir e mapear o container LUKS.
Formate o dispositivo mapeado
Prossiga para formatar o dispositivo mapeado conforme descrito em Btrfs#Sistema de arquivos em um único dispositivo, onde /dev/partition é o nome do dispositivo mapeado (ou seja, /dev/mapper/root) e não /dev/sda2.
Monte o dispositivo mapeado
Finalmente, monte o agora formatado dispositivo mapeado (isto é, /dev/mapper/raiz) para /mnt.
Criando subvolumes do btrfs
Esquema
Subvolumes serão usados como partições simuladas, mas outros subvolumes (aninhados) serão criados. A seguir uma representação parcial do que este seguinte exemplo vai gerar:
subvolid=5 | ├── @ - | | diretórios contidos: | ├── /usr | ├── /bin | ├── /.snapshots | ├── ... | ├── @home ├── @snapshots ├── @var_log └── @...
Esta seção segue Snapper#Layout do sistema de arquivos sugerido que é mais útil quando usado com o snapper. Você também deveria consultar Btrfs Wiki SysadminGuide#Layout.
Crie subvolumes para montagem inicial
Aqui estamos usando a convenção de prefixar @ para nomes de subvolumes que serão usados como pontos de montagem, e @ será o subvolume montado como /.
Seguindo o artigo Btrfs#Criando um subvolume, crie os subvolumes em /mnt/@, /mnt/@snapshots, e /mnt/@home.
Crie qualquer subvolume adicional que desejar como ponto de montagem.
Crie subvolumes para exclusões
Crie quaisquer subvolumes dos quais você não deseja ter snapshots ao tirar um snapshot de /. Por exemplo, você provavelmente não quer tirar snapshots de /var/cache/pacman/pkg. Esses subvolumes serão aninhados no subvolume @, mas com a mesma facilidade poderiam ter sido criados anteriormente no mesmo nível de @ de acordo com sua preferência.
Como o subvolume @ é montado em /mnt, você precisará criar um subvolume em /mnt/var/cache/pacman/pkg para este exemplo. Você pode ter que criar qualquer diretório pai primeiro.
Outros diretórios com os quais você pode querer fazer isso são /var/abs, /var/tmp e /srv.
Monte os subvolumes de nível superior
Desmonte a partição do sistema em /mnt.
Agora monte os subvolumes @ que irão servir como / para /mnt usando a opção de montagem subvol=. Assumindo que o nome do dispositivo mapeado é raiz, o comando deve se parecer com:
# mount -o compress=zstd,subvol=@ /dev/mapper/raiz /mnt
Veja Btrfs (Português)#Montando subvolumes para mais detalhes.
Também monte outros subvolumes para seus respectivos pontos de montagem: @home para /mnt/home e @snapshots para /mnt/.snapshots.
Monte a ESP
Se preparou uma partição de sistema EFI anteriormente, crie seu ponto de montagem e monte-a.
/efi, pois não é um sistema de arquivos Btrfs.Na etapa de instalação do pacstrap, btrfs-progs deve ser instalado em adição com o metapacote base.
Configurando o mkinitcpio
Crie a keyfile
Para que o GRUB abra a partição LUKS sem que o usuário digite sua senha duas vezes, usaremos um arquivo de chave embutido no initramfs. Siga Dm-crypt/Encriptação de dispositivo#Com uma keyfile no initramfs certificando-se de adicionar a chave a /dev/sda2 na etapa luksAddKey.
Edite o mkinitcpio.conf
Depois de criar, adicionar e colocar a chave como descrito acima, adicione o hook encrypt ao mkinitcpio.conf assim como quaisquer outros hooks que você precisar.
Gere novamente o initramfs depois de salvar as alterações. Veja dm-crypt/Configuração do sistema#mkinitcpio para detalhes e outros hooks que você pode precisar.
BINARIES=(btrfs) em seu etc/mkinitcpio.conf. Veja o artigo Btrfs#Recuperação de corrupção.Configurando o gerenciador de boot
Instale o GRUB em /dev/sda. Em seguida, edite /etc/default/grub conforme instruído em GRUB#Argumentos adicionais, GRUB#/boot criptografado e dm-crypt/Configuração do sistema#Usando o hook encrypt, seguindo ambas as instruções para uma partição raiz e de boot criptograda. Finalmente, gere o arquivo de configuração do GRUB. Observe que você precisará passar os parâmetros do kernel para o ponto de montagem raiz conforme instruído em Btrfs#Montando o subvolume como root.
Configurando a swap
Se você criou uma partição para ser usada como swap criptografada, agora é a hora de configurá-la. Siga as instruções em dm-crypt/Swap criptografada.
Raiz no ZFS
Raiz no ZFS pode ser configurado para criptografar tudo, exceto o gerenciador de boot. Veja o guia de instalação[link inativo 2023-04-23 ⓘ] na página do OpenZFS.
O carregador de inicialização pode ser verificado com Secure Boot em sistemas baseados em UEFI.
Veja também ZFS#Criptografia no ZFS utilizando dm-crypt.