dm-crypt (Português)/Encrypting an entire system (Português) - ArchWiki

# dm-crypt (Português)/Encrypting an entire system (Português)

From ArchWiki
< Dm-crypt (Português)
Jump to navigation Jump to search

Status de tradução: Esse artigo é uma tradução de Dm-crypt/Encrypting an entire system. Data da última tradução: 2020-05-25. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglê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.

## 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 nao 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. | Simples particionamento e configuração | Inflexível; o espaço em disco precisa ser alocado antes de criptografar
#LVM dentro do LUKS Consegue flexibilidade no particionamento ao usar LVM dentro de uma partição criptografada com LUKS. | Simples particionamento se sabe como usar LVM Somente uma chave para desbloquear todos os volumes (exemplo, configuração simples de resume-from-disk) design de volumes não é visível quando bloqueado Método mais fácil para suspensão para o disco | LVM adiciona mais uma camada adicional de mapeamento e hook Menos útil, se um volume deve receber uma chave separada
#LUKS dentro do LVM usa dm-crypt somente depois de configurar o LVM. | LVM pode ser usado para volumes criptografados em múltiplos discos Fácil de usar com grupos de volumes criptografados ou não | Complexo; para mudar volumes precisa modificar também os mapeadores de encriptação Volumes precisam de chaves individuais design de volumes não é visível quando bloquead
#LUKS dentro do RAID de software usa dm-crypt somente depois de configurar RAID. | Análogo ao LUKS dentro do LVM | Análogo ao LUKS dentro do LVM
#dm-crypt plain usa o modo plain (plano) do dm-crypt, sem cabeçalho do LUKS e suas opções para múltiplas chaves. Este cenário também permite que dispositivos USB possam ser usados no `/boot` e como depósito de chaves, que pode ser aplicado para outros cenários. | Melhor em relação aos dados para casos onde um cabeçalho do LUKS é danificado Permite encriptação total de disco Ajuda a solucionar problemas com SSDs | Necessário grande atenção a todos os parâmetros Encriptação de chave única e sem opção de mudança
#Partição de boot criptografada (GRUB) Mostra como criptografar a partição de boot usando o gerenciador de boot GRUB. Este cenário também usa uma partição de sistema EFI, que pode ser aplicado para outros cenários. | Mesmas vantagens do cenário de instalação en que é baseado (LVM dentro do LUKS neste particular exemplo) Menos dados são deixados sem criptografia, exemplo o gerenciador de boot e a partição de sistema EFI, se presente | Mesmas desvantagens do cenário de instalação en que é baseado (LVM dentro do LUKS neste particular exemplo) Configuração mais complicada Não é suportado por outros gerenciadores de boot
#Subvolumes do Btrfs com swap Mostra como criptografar um sistema Btrfs, incluindo o diretório `/boot`, também é possível adicionar uma partição para swap, em um hardware com suporte a UEFI. | similar a #Partição de boot criptografada (GRUB) Disponibilidade das funcionalidades do Btrfs | Similar a #Partição de boot criptografada (GRUB)

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/Especificidades#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/Especificidades#Suporte a discard/TRIM para unidades de estado sólido (SSD) para mais informações.

Atenção:

- 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:

    GRUB não suporta LUKS2.[1] Use LUKS1 em partições que o GRUB precisa ter acesso.
    o formato LUKS2 tem grande uso de RAM por escolha de design, o padrão é 1GB por mapeador criptografado. Máquinas com pouca RAM e/ou múltiplas partições LUKS2 abertas em paralelo podem falhar na inicialização. Veja a opção --pbkdf-memory para controlar o uso de memória.[2]

## LUKS em uma partição

Este exemplo demonstra um sistema criptografado com dm-crypt + LUKS em uma partição:

    +--------------------+-------------------------------+-----------------------+
    | Partição de boot   | Sistema criptogrado com LUKS2 | Espaço livre opcional |
    |                    | partição                      | para outras partições |
    |                    |                               |                       |
    | /boot              | /                             |                       |
    |                    |                               |                       |
    |                    | /dev/mapper/cryptraiz         |                       |
    |                    |-------------------------------|                       |
    | /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:

    # cryptsetup -y -v luksFormat /dev/sda2
    # cryptsetup open /dev/sda2 cryptraiz
    # mkfs.ext4 /dev/mapper/cryptraiz
    # mount /dev/mapper/cryptraiz /mnt

Verifique se o mapeamento funcionou como esperado:

    # umount /mnt
    # cryptsetup close cryptraiz
    # cryptsetup open /dev/sda2 cryptraiz
    # mount /dev/mapper/cryptraiz /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:

    # mkdir /mnt/boot
    # mount /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)

Dependendo de quais hooks estão sendo usados, a ordem pode ser relevante. 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:cryptraiz root=/dev/mapper/cryptraiz

Se está usando o hook sd-encrypt, o seguinte precisa ser definido ao invês:

    rd.luks.name=UUID-da-partição-raiz=cryptraiz root=/dev/mapper/cryptraiz

Veja dm-crypt/Configuração do sistema#Gerenciador de boot para detalhes.

o `UUID-da-partição-raiz` é para ser substituído pelo 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        |
    +-----------------------------------------------------------------------+ +------------------+

Nota: Ao usar o hook `encrypt`, você não poderá utilizar volumes lógicos espalhados em múltiplos discos; use o sd-encrypt ou veja dm-crypt/Especificidades#Modificando o hook encrypt para múltiplas partições.
Dica: Duas variações dessa configuração:

- Instruções em dm-crypt/Especificidades#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 `/boot` criptografada, 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.

Dica: Se usa o gerenciador de boot GRUB para inicialização com BIOS de um disco GPT, crie uma Partição de inicialização de BIOS.

Crie uma partição que será montada em `/boot` com o tamanho de 200 MiB ou mais.

Dica: sistemas UEFI systems podem usar a Partição de sistema EFI para a `/boot`.

Crie uma partição que depois irá conter o container criptografado.

Crie o container criptografado com LUKS na partição do sistema. Enter com 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 nomeado `MeuGrupoVol` (ou o que você desejar), e adicione ao, anteriormente criado, volume físico:

    # 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
    # mkdir /mnt/home
    # mount /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

Dica: Se optar por manter o `/boot` em uma Partição de sistema EFI a formatação recomendada é

    # mkfs.fat -F32 /dev/sdb1

Crie o diretório `/mnt/boot`:

    # mkdir /mnt/boot

Monte a partição para `/mnt/boot`:

    # mount /dev/sdb1 /mnt/boot

### Configurando o mkinitcpio

Tenha certeza que o pacote lvm2 está instalado, e adicione os hooks `keyboard`, `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 sd-lvm2 filesystems fsck)

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 está usando o hook sd-encrypt ou dracut, o seguinte precisa ser definido ao invês:

    rd.luks.name=UUID-do-dispositivo=cryptlvm root=/dev/MeuGrupoVol/raiz

o `UUID-do-dispositivo` precisa ser substituído pelo UUID da partição raiz, nesse caso `/dev/sda1`. Veja Nomeação persistente de dispositivo de bloco para mais detalhes.

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.

Dica: Diferente do #LVM dentro do LUKS, este método permite usar volumes lógicos espalhados em múltiplos discos.

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/Especificidades#Expandindo LVM em múltiplos discos. Vale notar que o container criptografado com LUKS precisa ser redimensionado também.

This article or section needs expansion.

Reason: A introdução desse cenário precisa de alguns ajustes, já que agora existem comparações em #Visão geral. Uma estrutura sugerida é a introdução presente em #LUKS em uma partição. (Discuss in talk:dm-crypt/Encrypting an entire system)

### 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                                                    |
    +------------------+------------------------------------------------------------------------------------------------+

sobrescreva `/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.

Dica: Se você precisar acessar a raiz criptografada pelo archiso, a ação `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
    # mkdir /mnt/boot
    # mount /dev/sda1 /mnt/boot

### Configurando o mkinitcpio

Tenha certeza 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 sd-lvm2 filesystems fsck)

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 ao invés:

    rd.luks.name=UUID-do-dispositivo=raiz root=/dev/mapper/raiz

O `UUID-do-dispositivo` precisa ser substituído pelo UUID do `/dev/MeuGrupoVol/cryptraiz`. Veja Nomeação persistente de dispositivo de bloco para detalhes.

Veja dm-crypt/Configuração do sistema#Gerenciador de boot para mais informação sobre.

### 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.

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/cryptraiz | |               |                | /dev/mapper/cryptraiz | |                     |
    |               +----------------+-----------------------+ |               +----------------+-----------------------+ |                     |
    |               | 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/cryptdata|
    |               +----------------+-----------------------+ |               |+---------------+-----------------------+ +---------------------+
    | /dev/sda1     | /dev/sda2      | /dev/sda3             | | /dev/sdb1     | /dev/sdb2      | /dev/sdb3             | | /dev/sdc1           |
    +---------------+----------------+-----------------------+ +---------------+----------------+-----------------------+ +---------------------+

Tenha certeza de substituir eles com os dispositivos apropriados para sua situação, eles 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.

Nota:

- 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).

Encripte `/dev/md/raiz`:

Atenção: GRUB não suporta LUKS2. Use LUKS1 (`--type luks1`) nas partições que o GRUB precisa acessar.

    # cryptsetup -y -v luksFormat --type luks1 /dev/md/raiz
    # cryptsetup open /dev/md/raiz cryptraiz
    # mkfs.ext4 /dev/mapper/cryptraiz
    # mount /dev/mapper/cryptraiz /mnt

e faça o mesmo para o HDD:

    # cryptsetup -y -v luksFormat /dev/sdc1
    # cryptsetup open /dev/sdc1 cryptdata
    # mkfs.ext4 /dev/mapper/cryptdata
    # mkdir /mnt/data
    # mount /dev/mapper/cryptdata /mnt/data

Para sistemas UEFI, defina a ESP (partição de sistema EFI):

    # mkfs.fat -F32 /dev/md/ESP
    # mount /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:cryptraiz"
    GRUB_ENABLE_CRYPTODISK=y

Veja dm-crypt/Configuração do sistema#Gerenciador de boot 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/crypttab` para 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 cryptraiz e cryptdata e o ESP:

    /dev/mapper/cryptraiz  /           ext4    rw,noatime  0   1
    /dev/mapper/cryptdata  /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

Save 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/Especificidades#Suporte a discard/TRIM para unidades de estado sólido (SSD).

Dica: Se deseja encriptação sem cabeçalho mas não está com certeza sobre a falta de derivação de chaves com o modo plain, pode usar uma destas duas alternativas:

- 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    |
    +-----------------------------------------------------------------------+ +----------------+ +---------------+

Dica:

- É 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 hook `encrypt` ler a keyfile na imagem initramfs, use o prefixo `rootfs:` antes do nome do arquivo, exemplo `cryptkey=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

Dica: Uma alternativa simples para o LVM, em casos do FAQ do cryptsetup onde ele não é necessário, é somente criar um sistema de arquivos com todo o dispositivo mapeado.

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
    # mkdir /mnt/home
    # mount /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.ext4 /dev/sdb1
    # mkdir /mnt/boot
    # mount /dev/sdb1 /mnt/boot

### Configurando mkinitcpio

Tenha certeza que o pacote lvm2 está instalado, e adicione os hooks `keyboard`, `encrypt` e `lvm2` no mkinitcpio.conf:

    HOOKS=(base udev autodetect keyboard keymap consolefont modconf block encrypt lvm2 filesystems fsck)

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#Gerenciador de boot para mais detalhes e outros parâmetros que você pode precisar.

Dica: Se está usando o GRUB, você pode instalar no mesmo pendrive da partição /boot com:

    # 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 ext4 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                    |
    +--------------------+---------------------+-----------------------------------------------------------------------+

Dica:

- 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 `cryptboot` do 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:

Atenção: GRUB não suporta LUKS2. Use LUKS1 (`--type luks1`) em partições que o GRUB precisa acessar.

    # 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:

    # mkdir /mnt/efi
    # mount /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

Tenha certeza que o pacote lvm2 está instalado, e adicione os hooks `keyboard`, `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 sd-lvm2 filesystems fsck)

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#Gerenciador de boot e GRUB#/boot criptografado for details. `UUID-do-dispositivo` faz referência ao UUID do `/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

This article or section is a candidate for merging with Dm-crypt/Encriptação de dispositivo#Com uma keyfile no initramfs.

Notes: Muito conteudo replicado, detalhes demais para uma página de visão geral. (Discuss in Talk:Dm-crypt/Encrypting an entire system#Security Issue with Grub Keyfile)

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.

Dica: Se quer criptografar a partiçã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.

Atenção: Não use arquivo swap no Btrfs nas versões do kernel Linux anteriores à 5.0, pode resultar em perca de dados. Veja Btrfs#Swap file.

    +-----------------------+-------------------------+------------------+
    | 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

Nota: Não é possível utilizar o btrfs como descrito em Btrfs#Partitionless Btrfs disk ao usar o LUKS. Particionamento tradicional deve ser usado, mesmo se é somente para criar uma partição.

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

Atenção: GRUB não suporta LUKS2. Use LUKS1 (`--type luks1`) em partições que ele precisa acessar.

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

Formate o dispositivo mapeado como descrito em Btrfs#File system on a single device, onde `/dev/partition` é o nome do dispositivo mapeado (i.e., `cryptraiz`) e não `/dev/sda2`.

#### Monte o dispositivo mapeado

Finalmente, monte o agora formatado dispositivo mapeado (i.e., `/dev/mapper/cryptraiz`) para `/mnt`.

### Criando subvolumes do btrfs

This article or section is a candidate for merging with Btrfs.

Notes: O esboço do subvolume não é específico para um sistema criptografado. (Discuss in talk:dm-crypt/Encrypting an entire system)

#### Esboço

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 (/dev/sda2)
       |
       ├── @ (montado como /)
       |       |
       |       ├── /bin (diretório)
       |       |
       |       ├── /home (subvolume @home montado)
       |       |
       |       ├── /usr (diretório)
       |       |
       |       ├── /.snapshots (subvolume @snapshots montado)
       |       |
       |       ├── /var/cache/pacman/pkg (subvolume aninhado)
       |       |
       |       ├── ... (outros diretórios e subvolumes aninhados)
       |
       ├── @snapshots (montado como /.snapshots)
       |
       ├── @home (montado como /home)
       |
       └── @... (subvolumes adicionais que você deseja usar como ponto de montagem)

Este seção segue Snapper#Suggested filesystem layout que é mais útil quando usado com o snapper. Você também deveria consultar Btrfs Wiki SysadminGuide#Layout.

#### Crie os subvolumes de nível superior

Será utilizada a convenção do prefixo `@` para os nomes do subvolume que serão usados como ponto de montagem, e`@` será o subvolume montado como `/`.

Seguindo o artigo Btrfs#Creating a subvolume, crie os subvolumes em `/mnt/@`, `/mnt/@snapshots`, e `/mnt/@home`.

Crie qualquer subvolume adicional que desejar como ponto de montagem.

#### 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 é `cryptraiz`, o comando deve se parecer com:

    # mount -o compress=zstd,subvol=@ /dev/mapper/cryptraiz /mnt

Veja Btrfs#Mounting subvolumes para mais detalhes.

Também monte outros subvolumes para seus respectivos pontos de montagem: `@home` para `/mnt/home` e `@snapshots` para `/mnt/.snapshots`.

#### Crie os subvolumes aninhados

Crie quaisquer subvolumes que você não deseja ter snapshots quando tirar uma snapshot do `/`. Por exemplo, você provavelmente não quer tirar snapshots do `/var/cache/pacman/pkg`. estes subvolumes serão aninhados dentro do subvolume `@`, mas facilmente você conseguiria criar no mesmo nível do `@` se for de acordo com sua preferência.

Desde que o subvolume `@` está montado em `/mnt` será necessário criar um subvolume em `/mnt/var/cache/pacman/pkg` para este exemplo. você pode ser necessário criar diretórios anteriores ao pkg.

Outros diretórios que você pode desejar fazer isso são `/var/abs`, `/var/tmp`, e `/srv`.

#### Monte a ESP

Se preparou uma partição de sistema EFI anteriormente, crie seu ponto de montagem e monte-a.

Nota: As snapshots do btrfs não irão incluir o `/efi`, desde que este não faz parte de um sistema de arquivos btrfs.

No passo do guia de instalação onde tem o pacstrap, btrfs-progs deve ser instalado em adição com o metapacote base.

### Configurando o mkinitcpio

#### Crie a keyfile

Para o GRUB abrir a partição LUKS sem que o usuário digite a senha duas vezes, coloque uma keyfile no initramfs. Siga dm-crypt/Encriptação de dispositivo#Com uma keyfile no initramfs, tenha certeza de adicionar a chave para `/dev/sda2` do passo luksAddKey.

#### Edite o mkinitcpio.conf

Depois de criar, adicionar e colocar a chave como descrito acima, adicione o hook `encrypt` no mkinitcpio.conf e também outros hooks que precise. Veja dm-crypt/Configuração do sistema#mkinitcpio para informações detalhadas.

Dica: Você pode querer adicionar `BINARIES=(/usr/bin/btrfs)` para sua `mkinitcpio.conf`. Veja o artigo Btrfs#Corruption recovery.

### Configurando o gerenciador de boot

Instale o GRUB em `/dev/sda`. Então, edite `/etc/default/grub` como sugerido em GRUB#Argumentos adicionais, GRUB#/boot criptografado e dm-crypt/Configuração do sistema#Usando o hook encrypt, siga ambas as instruções para o sistema criptografado e a partição de boot. Depois, gere o arquivo de configuração do GRUB.

### Configurando a swap

Se você criou uma partição para ser usada como swap criptografada, siga as instruções em dm-crypt/Swap criptografada para configurá-la.

Categories:

- Data-at-rest encryption (Português)
- Installation process (Português)

Hidden categories:

- Pages or sections flagged with Template:Expansion
- Pages or sections flagged with Template:Merge