dm-crypt (Português)/System configuration (Português)

From ArchWiki

This article or section needs expansion.

Reason: Agregar aqui todas informações genéricas relacionadas a configuração do sistema de outros sub-artigos do dm-crypt. (Discuss in talk:dm-crypt/System configuration)
Status de tradução: Esse artigo é uma tradução de Dm-crypt/System configuration. Data da última tradução: 2021-02-15. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.
Dica:

mkinitcpio

Em alguns cenários, um subconjunto dos seguintes hooks do mkinitcpio terão que ser habilitados:

busybox systemd Caso de uso
encrypt sd-encrypt Sempre necessário quando a partição raiz, ou outra partição que precisa ser montada antes dela, é criptografada. Não é necessário em todos os casos, scripts de inicialização de sistema como crypttab cuidam do desbloqueio de outras partições criptografadas. Deve ser colocado depois do hook udev ou systemd.
keyboard Necessário para o funcionamento do teclado no estágio inicial do espaço do usuário.
keymap sd-vconsole Trás suporte a teclados que não são do padrão US; deve ser colocado antes do hook encrypt. Defina seu padrão do seu teclado em /etc/vconsole.conf, veja Configuração de teclado no console#Configuração persistente.
consolefont Carrega uma fonte alternativa para o console no estágio inicial do espaço do usuário. Defina sua fonte em /etc/vconsole.conf, veja Console do Linux#Configuração persistente.

Outros hooks necessários devem ser claramente especificados durante a instalação do sistema.

Gere novamente o initramfs depois de salvar as mudanças.

Exemplos

Uma configuração típica em /etc/mkinitcpio.conf quando se usa o hook encrypt é: 

/etc/mkinitcpio.conf
...
HOOKS=(base udev autodetect keyboard keymap consolefont modconf block encrypt lvm2 filesystems fsck)
...

Já uma configuração com o initramfs baseado no systemd, fazendo uso do hook sd-encrypt, seria semelhante a: 

/etc/mkinitcpio.conf
...
HOOKS=(base systemd autodetect keyboard sd-vconsole modconf block sd-encrypt lvm2 filesystems fsck)
...

Gerenciador de boot

Para habilitar a inicialização em uma partição raiz criptografada, um subconjunto dos seguintes parâmetros do kernel terão que ser configurados. Veja Parâmetros do kernel para instruções específicas para seu Gerenciador de boot.

Por exemplo, se está usando o GRUB, os parâmetros relevantes são adicionados no /etc/default/grub, antes de gerar o arquivo de configuração principal. Veja também GRUB#Aviso ao instalar em chroot como outro ponto a se atentar.

Os parâmetros do kernel irão variar de acordo com qual hook (encrypt ou sd-encrypt) você vai usar.

Parâmetros do Kernel

Parâmetros do kernel como root e resume são especificados da mesma forma para os hooks encrypt e sd-encrypt.

root

O parâmetro root= especifica o dispositivo do sistema de arquivos raiz (descriptografado): 

root=dispositivo
  • Se o sistema de arquivos foi colocado diretamente no dispositivo descriptografado, o caminho será /dev/mapper/dmnome.
  • Se LVM vai ser ativado primeiro e contém um volume lógico raiz criptografado, a forma acima também é aplicável.
  • Se o sistema de arquivos raiz está no volume lógico de uma LVM criptografada, o mapeador de dispositivos vai estar em sua forma genérica root=/dev/grupoDoVolume/volumeLógico.
Dica: Se usa o GRUB e está gerando o arquivo grub.cfg com grub-mkconfig, este parâmetro não precisa se especificado manualmente. grub-mkconfig determinará o UUID correto do sistema de arquivos raiz e automaticamente vai colocá-lo no grub.cfg.

resume

resume=dispositivo
  • dispositivo nesse caso é a swap descriptografada, este parâmetro é utilizado com o objetivo de suspender para o disco. Se a swap está em uma partição separada, ela estará na forma de /dev/mapper/partição_swap. Veja também dm-crypt/Swap criptografada.

Usando o hook encrypt

Nota: Comparado com o hook sd-encrypt, o hook encrypt não suporta:

cryptdevice

Este parâmetro fará o sistema solicitar a senha para abrir o dispositivo contendo a raiz criptografada na primeira inicialização (cold boot). Ele é utilizado para o hook encrypt identificar o dispositivo que contém o sistema criptografado: 

cryptdevice=dispositivo:nomedm
  • dispositivo é o caminho para o container criptografado que contém o sistema. É fortemente recomendado o uso de nomeação persistente de dispositivo de bloco.
  • nomedm é o nome do dispositivo mapeado que será dado ao container descriptografado, que estará disponível como /dev/mapper/nomedm.
  • Se possui um volume lógico raiz criptografado, LVM vai ser ativado primeiro, o grupo de volumes e o volume lógico raiz serão o dispositivo. Coloque da seguinte forma cryptdevice=/dev/grupo_de_volumes/volume_lógico_raiz:nomedm.
Dica: Você pode querer habilitar suporte ao Discard/TRIM[link quebrado: seção inválida] para unidades de estado sólido (SSD).

cryptkey

Este parâmetro especifica a localização de uma keyfile, o hook encrypt é necessário para ler e abrir o cryptdevice (a menos que a chave está em um caminho padrão, veja abaixo). Três parâmetros podem ser definidos, dependendo de como a keyfile existe, pode ser um arquivo no dispositivo, uma bitstream que começa em uma localização específica ou um arquivo incluido no initramfs.

Para um arquivo no dispositivo o formato é: 

cryptkey=dispositivo:tipo_do_sistema_de_arquivos:caminho
  • dispositivo é o dispositivo de bloco onde a keyfile se encontra. Uso de nomeação persistente de dispositivo de bloco é fortemente recomendado.
  • tipo_do_sistema_de_arquivos é o tipo do sistema de arquivos do dispositivo (ou auto).
  • caminho é o caminho absoluto da keyfile dentro do dispositivo.

Exemplo: cryptkey=LABEL=pendrive:vfat:/chave_secreta

Para uma bitstream no dispositivo, a localização é especificada com: 

cryptkey=dispositivo:início:tamanho

Onde início e tamanho estão em bytes. Por exemplo, cryptkey=UUID=ZZZZZZZZ-ZZZZ-ZZZZ-ZZZZ-ZZZZZZZZZZZZ:0:512 lê uma keyfile de 512 byte no começo do dispositivo.

Dica: Se o caminho do dispositivo que você quer acessar contém o caracter :, terá que escapar isto com \. Neste caso o parâmetro cryptkey deve ser semelhante a: cryptkey=/dev/disk/by-id/usb-123456-0\:0:0:512, este exemplo é de um pendrive com o id usb-123456-0:0.

Para um arquivo incluído no initramfs o formato é[1]: 

cryptkey=rootfs:caminho

Exemplo: cryptkey=rootfs:/chave_secreta

Também note que se cryptkey não é especificada, o padrão /crypto_keyfile.bin (arquivo incluído no initramfs) será utilizado.[2]

Veja também dm-crypt/Encriptação de dispositivo#Keyfiles.

crypto

Este parâmetro é especifíco para passar opções do modo plain do dm-crypt para o hook encrypt.

Sua forma é: 

crypto=<hash>:<cifra>:<tamanho_da_chave>:<início>:<pule>

Os argumentos são relacionados diretamente a opções do cryptsetup. Veja dm-crypt/Encriptação de dispositivo#Opções de encriptação para o modo plain.

Para um disco criptografado com somente as opções padrão do modo plain, o argumento crypto deve ser especificado, mas cada entrada pode ser vazia: 

crypto=::::

Um exemplo especifíco é: 

crypto=sha512:twofish-xts-plain64:512:0:

Usando o hook sd-encrypt

Todos os seguintes rd.luks podem ser trocados por luks. Os parâmetros rd.luks são somente reconhecidos pelo initrd, enquanto luks são reconhecidos tanto pelo sistema quanto pelo initrd. A menos que você queira controlar os dispositivos com argumentos dados ao kernel enquanto o sistema é inicializado, use rd.luks. Veja systemd-cryptsetup-generator(8) para mais informações e detalhes.

Dica:
  • Se o arquivo /etc/crypttab.initramfs existe, mkinitcpio o adicionará ao initramfs como /etc/crypttab, você pode especificar nele dispositivos que precisam ser desbloqueados durante a inicialização. Sintaxe é documentada em #crypttab e crypttab(5).
  • /etc/crypttab.initramfs não é limitado somente ao uso do UUID como o rd.luks. Você pode usar qualquer um dos métodos de nomeação persistente de dispositivo de bloco.
  • Senhas entradas durante a inicialização são salvas em cache no chaveiro do kernel pelo systemd-cryptsetup(8), então se multiplos dispositivos podem ser abertos com a mesma senha (isto inclui os dispositivos no crypttab que são abertos depois da inicialização), então você precisará entrar cada senha somente uma vez.
Nota:
  • Todos os parâmetros do rd.luks podem ser especificados múltiplas vezes para múltiplos volumes criptografados LUKS.
  • Os parâmetros do rd.luks somente suportam dispositivos LUKS detectáveis. Para abrir um dispositivo dm-crypt plain ou com cabeçalho do LUKS desanexado, você deve especificá-lo em /etc/crypttab.initramfs. Veja #crypttab para a sintaxe.
Atenção: Se você está usando o /etc/crypttab ou /etc/crypttab.initramfs junto com os parâmetros luks.* ou rd.luks.*, somente os dispositivos especificados na linha de comando do kernel serão ativados e você verá Not creating device 'devicename' because it was not specified on the kernel command line.. Para ativar todos os dispositivos em /etc/crypttab não especifique nenhum parâmetro luks.* e use rd.luks.*. Para ativar todos os dispositivos em /etc/crypttab.initramfs não especifique nenhum parâmetro luks.* or rd.luks.*.

rd.luks.uuid

Dica: rd.luks.uuid pode ser omitido ao usar rd.luks.name.
rd.luks.uuid=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX

Especifique o UUID do dispositivo a ser aberto na inicialização com este parâmetro. Se o UUID está em /etc/crypttab.initramfs, as opções listadas lá serão utilizadas. Para opções do luks.uuid, o /etc/crypttab.initramfs ou /etc/crypttab será usado.

Por padrão o dispositivo mapeado estará localizado en /dev/mapper/luks-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX onde XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX é o UUID da partição LUKS.

rd.luks.name

Dica: Ao usar este parâmetro, você pode omitir rd.luks.uuid.
rd.luks.name=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX=nome

Especifique o nome do dispositivo mapeado depois que a partição LUKS é aberta, onde XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX é o UUID dela. É equivalente ao segundo parâmetro do encrypt, cryptdevice.

Exemplo, especificar rd.luks.name=12345678-9ABC-DEF0-1234-56789ABCDEF0=cryptraiz faz o dispositivo LUKS aberto do UUID 12345678-9ABC-DEF0-1234-56789ABCDEF0 estar localizado em /dev/mapper/cryptroot.

rd.luks.options

rd.luks.options=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX=opções

ou 

rd.luks.options=opções

Defina as opções para um dispositivo especificado com o UUID ou, se não especificado, para todos os UUIDs especificados em outro lugar (e.g., crypttab).

É relativamente equivalente ao terceiro parâmetro do encrypt, cryptdevice.

Segue um formato similar às opções usadas no crypttab - opções são separadas por vírgulas, opções com valores são especificados com opção=valor.

Exemplo: 

rd.luks.options=timeout=10s,swap,cipher=aes-cbc-essiv:sha256,size=256

rd.luks.key

Especifique a localização da keyfile que será utilizada para abrir o dispositivo especificado com o UUID. Não há uma localização padrão para a keyfile, como existe com o parâmetro do hook encrypt, cryptkey.

Se a keyfile está incluída no initramfs: 

rd.luks.key=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX=/caminho/para/keyfile

ou 

rd.luks.key=/caminho/para/keyfile
Dica: Todo o parâmetro rd.luks.key pode ser omitido se a keyfile está incluída em /etc/cryptsetup-keys.d/nome.key.

Se a keyfile está em outro dispositivo: 

rd.luks.key=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX=/caminho/para/keyfile:UUID=ZZZZZZZZ-ZZZZ-ZZZZ-ZZZZ-ZZZZZZZZZZZZ

Substitua UUID=ZZZZZZZZ-ZZZZ-ZZZZ-ZZZZ-ZZZZZZZZZZZZ com o identificador do dispositivo que a keyfile está localizada. Se o sistema de arquivos utilizado não é o mesmo do sistema raiz, você deve incluir o módulo dele no initramfs.

Atenção: rd.luks.key com uma keyfile em outro dispositivo por padrão não vai pedir a senha caso este não estiver disponível. Para solicitar a senha, especifique a opção keyfile-timeout= no rd.luks.options. Exemplo, para uma espera de 10 secondos: 
rd.luks.options=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX=keyfile-timeout=10s

Timeout

Existem duas opções que irão afetar o tempo de espera até a senha ser solicitada durante a inicialização:

  • rd.luks.options=timeout=tempo_limite especifica o tempo máximo para achar a senha
  • rootflags=x-systemd.device-timeout=tempo_limite especifica o quanto systemd deve esperar pelo dispositivo até desistir (padrão 90 segundos)

Se deseja desabilitar os tempos de espera, então defina ambos para zero: 

rd.luks.options=timeout=0 rootflags=x-systemd.device-timeout=0

crypttab

O arquivo /etc/crypttab (tabela de dispositivos criptografados) é similar ao arquivo fstab e contém uma lista de dispositivos criptografados que serão abertos durante a inicialização. Este arquivo pode ser usado para montar automaticamente dispositivos swap ou sistemas de arquivos não raiz.

crypttab é lido antes do fstab, então os containers do dm-crypt podem ser abertos antes que o sistema de arquivos seja montado. Note que crypttab é lido depois que o sistema inicia, logo não é um substituto para abrir partições criptografadas com os hooks do mkinitcpio e opções do gerenciador de boot como no caso de criptografar a partição raiz. A leitura do crypttab é feita na inicialização pelo systemd-cryptsetup-generator automaticamente.

Veja crypttab(5) para detalhes, veja abaixo alguns exemplos, e a seção #Montando na inicialização para instruções de como usar UUIDs para montar um dispositivo criptografado.

Atenção:
  • Se a opção nofail é especificada, a tela de entrada da senha pode desaparecer enquanto digita. nofail deve então somente ser usada junto com keyfiles.
  • Existem problemas no systemd quando ele processa entradas do crypttab para o modo plain (--type plain) do dm-crypt:
    • Para dispositivos --type plain com uma keyfile, é necessário adicionar a opção hash=plain para o crypttab devido a uma incompatibilidade do systemd[link inativo 2024-10-12 ⓘ]. Não use systemd-cryptsetup manualmente para a criação do dispositivo como medida provisória.
    • Pode ser necessário adicionar a opção plain explicitamente para forçar systemd-cryptsetup a reconhecer o dispositivo (--type plain) na inicialização. Veja issue do systemd 442.
/etc/crypttab
# Exemplo de um arquivo crypttab. campos são: nome, dispositivo criptografado, senha, opções do cryptsetup.

# Monte /dev/lvm/swap criptografando-a com uma nova chave a cada inicialização.
 swap	/dev/lvm/swap	/dev/urandom	swap,cipher=aes-xts-plain64,size=256

# Monte /dev/lvm/tmp como /dev/mapper/tmp usando o modo plain do dm-crypt com uma senha randômica, fazendo seu conteúdo não recuperável depois de desmontada.
tmp	/dev/lvm/tmp	/dev/urandom	tmp,cipher=aes-xts-plain64,size=256 

# Monte /dev/lvm/home como /dev/mapper/home usando LUKS, solicite a senha durante a inicialização.
home   /dev/lvm/home

# Monte /dev/sdb1 como /dev/mapper/backup usando LUKS, com uma senha guardada em um arquivo.
backup /dev/sdb1       /home/alice/backup.key

Para testar seu crypttab imediatamente depois de editá-lo, recarregue o gerenciador de configuração do systemd com: 

# systemctl daemon-reload

e inicie o recentemente gerado systemd-cryptsetup@nome.service. 

# cryptsetup status name
/dev/mapper/name is active.
  type:    ...
  cipher:  ...
  keysize: ... bits
  key location: ...
  device:  /dev/sdxN
  sector size:  ...
  offset:  ... sectors
  size:    ... sectors
  mode:    ...
  flags:   ...

Para mais informações sobre systemd-cryptsetup@nome.service, veja #Montando em demanda.

Dica: Se você usa GPT e tipo específico de partição UUIDs, você pode evitar crypttab e fstab para alguns pontos de montagem com systemd. Para mais informações veja systemd#Montagem automática de partição GPT.

Montando na inicialização

Se você quer montar uma unidade de armazenamento criptografada na inicialização, você pode colocar o UUID do dispositivo em /etc/crypttab. Para descobrir o UUID (da partição) pode usar o comando lsblk -f e adicioná-lo ao crypttab desse jeito: 

/etc/crypttab
disco_externo         UUID=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX        none    luks,timeout=180

O primeiro parâmetro é o nome que o dispositivo criptografado vai receber quando aberto(que fica a sua preferência). A opção none fará a senha ser solicitada durante a inicialização. A opção timeout define um tempo de espera máximo em segundos para entrar com a senha.

Dica: Senhas entradas no prompt de senha são salvas no chaveiro do kernel pelo systemd-cryptsetup(8) (quando usar o hook sd-encrypt, isto também inclui senhas entradas no estágio do initramfs). Se um dispositivo no crypttab usa uma senha já entrada, o terceiro parâmetro pode ser definido para none e a senha salva em cache será automaticamente usada.
Nota: Tenha em mente que a opção timeout em crypttab somente determina a quantidade de tempo permitida para entrar com a senha. Adicionalmente, systemd também tem um tempo de espera máximo para o dispositivo estar disponível (90 segundos por padrão), que é independente do temporarizador da senha. Consequentemente, até quando a opção timeout em crypttab é definida para um valor maior que 90 segundos (ou está no seu valor padrão 0, sem limite de tempo), systemd esperará no máximo 90 segundos para o dispositivo ser aberto. Para mudar isso, a opção x-systemd.device-timeout (veja systemd.mount(5)) pode ser definida no fstab para tal dispositivo. Provavelmente é desejado que a quantidade de tempo da opção timeout no crypttab é igual a presente na opção x-systemd.device-timeout no fstab para cada dispositivo montado na inicialização.

Desbloqueando com uma keyfile

Se a keyfile para um sistema de arquivos não raiz está guardada dentro do sistema criptografado, ela está segura quando o sistema está desligado e pode ser automaticamente aberto durante a inicialização via crypttab. Por exemplo, abrir um dispositivo especificado com UUID: 

/etc/crypttab
home    UUID=<identificador UUID>    /etc/cryptsetup-keys.d/home-crypt.key
Dica:
  • Se uma keyfile não é especificada, systemd-cryptsetup(8) irá automaticamente tentar carregá-la de /etc/cryptsetup-keys.d/nome.key e /run/cryptsetup-keys.d/nome.key.[3]
  • Se você prefere usar o modo --plain, as opções de encriptação necessárias para abrir o dispositivo deverão ser especificadas no /etc/crypttab. Tome cuidado ao fazer a medida provisória mencionada no crypttab.

Use o nome do dispositivo mapeado (definido no /etc/crypttab) para fazer a entrada no /etc/fstab: 

/etc/fstab
/dev/mapper/home        /home   ext4        defaults        0       2

Desde que /dev/mapper/home já é uma mapeação única, não existe a necessidade de especificar o UUID dele. Em qualquer caso, o sistema de arquivos mapeado vai ter um UUID diferente da partição criptografada.

Montando um dispositivo de bloco empilhado

Os geradores do systemd também processam automaticamente os dispositivos de bloco empilhados na inicialização.

Por exemplo, você pode usar o cryptsetup numa configuração do RAID e criar um volume lógico LVM com o sistema de arquivos dentro de um dispositivo de bloco criptografado. Resultando em: 

$ lsblk -f
─sdXX                  linux_raid_member    
│ └─md0                 crypto_LUKS   
│   └─cryptedbackup     LVM2_member 
│     └─vgraid-lvraid   ext4              /mnt/backup
└─sdYY                  linux_raid_member    
  └─md0                 crypto_LUKS       
    └─cryptedbackup     LVM2_member 
      └─vgraid-lvraid   ext4              /mnt/backup

A senha será solicitada e ele será montado na inicialização.

Ao especificar corretamente as entradas do crypttab (exemplo, UUID para o dispositivo crypto_LUKS) e fstab (/dev/vgraid/lvraid), não há necessidade para configurações/hooks adicionais no mkinitcpio, devido ao processamento do /etc/crypttab aplicado às partições não raiz somente. Existe uma exceção, quando o hook mdadm_udev já é usado (exemplo, o dispositivo raiz). Neste caso é necessário atualizar o /etc/madadm.conf e o initramfs para que a raid raiz correta seja selecionada.

Montando em demanda

Ao invés de: 

# cryptsetup luksOpen UUID=... disco_externo

Você pode iniciar o systemd-cryptsetup@disco_externo.service, quando você tem uma entrada como a seguir em seu /etc/crypttab: 

/etc/crypttab
disco_externo UUID=... none noauto

Desta maneira você não precisa se lembrar exatamente das opções do crypttab. A senha será solicitada se necessário.

O arquivo correspondente unit é gerada automaticamente pelo systemd-cryptsetup-generator(8). Você pode listar todos os arquivos unit gerados usando: 

$ systemctl list-unit-files | grep systemd-cryptsetup

Solução de problemas

Sistema travado no prompt de inicialização/senha não aparece

Se você está usando Plymouth, tenha certeza de usar os módulos corretos (veja Plymouth#O hook do plymouth) ou desabilite isso. De outra forma, Plymouth irá atrapalhar o prompt de senha, impedindo o sistema de inicializar.