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 mlocate 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 .
- 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/Criptografia do dispositivo#Tamanho do setor.
# 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 , e em mkinitcpio.conf. Se deseja padrão de teclado US, você pode omitir o hook .
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 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.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 .
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 , 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
Monte a partição para :
# mount --mkdir /dev/sdb1 /mnt/boot
Configurando o mkinitcpio
Certifiique-se de que o pacote está instalado e adicione os hooks , , 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 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 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:
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.
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 está instalado, e adicione os hooks , lvm2 e 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 refere-se ao UUID do . 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:
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
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 .
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
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 .
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: para MBR ou GUID para GPT.
Uma vez que as partições forem criadas em , 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 () para todo o disco.
Fazendo o arranjo RAID
Crie o arranjo RAID para os SSDs.
# 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 e um dispositivo criptografado com uma chave randômica. Alternativamente, você pode usar com ou , 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 ( neste exemplo).
Configure a criptografia para :
--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 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 :
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 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 .
- Crie outra keyfile para o HDD () 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).
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 é:
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 , 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 :
# 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 está instalado e adicione os hooks , keymap, 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.
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 pode ser adicionada na linha relevante em :
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 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 é:
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 .
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 /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 .
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 para compatibilidade com e monte:
# mount --mkdir /dev/sda2 /mnt/efi
Neste ponto, você deve ter as seguintes partições e volumes lógicos dentro de :
Configurando o mkinitcpio
Certifique-se de que o pacote está instalado, e adicione os hooks , keymap, 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:
Defina os parâmetros do kernel, para que o initramfs possa abrir a partição raiz criptografada. Se for usar o hook :
Se for usar o hook sd-encrypt, o seguinte precisa ser definido:
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:
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 :
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 . /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.
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 . 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.
Crie o container LUKS
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 é o nome do dispositivo mapeado (ou seja, ) e não /dev/sda2.
Monte o dispositivo mapeado
Finalmente, monte o agora formatado dispositivo mapeado (isto é, ) para .
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:
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/@, , 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 . 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 , você precisará criar um subvolume em 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 , e .
Monte os subvolumes de nível superior
Desmonte a partição do sistema em .
Agora monte os subvolumes que irão servir como / para usando a opção de montagem . Assumindo que o nome do dispositivo mapeado é , o comando deve se parecer com:
# mount -o compress=zstd,subvol=@ /dev/mapper/raiz /mnt
Veja Btrfs#Mounting subvolumes para mais detalhes.
Também monte outros subvolumes para seus respectivos pontos de montagem: @home para e @snapshots para .
Monte a ESP
Se preparou uma partição de sistema EFI anteriormente, crie seu ponto de montagem e monte-a.
Na etapa de instalação do pacstrap, deve ser instalado em adição com o metapacote .
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 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.
Configurando o gerenciador de boot
Instale o GRUB em . Em seguida, edite 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 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.