17.12. Criptografando Partições de Disco
Anterior | Capítulo 17. Armazenamento | Próxima

## 17.12. Criptografando Partições de Disco

Contribuido por Lucky Green.

O FreeBSD oferece excelentes proteções on-line contra acesso não autorizado a dados. As permissões de arquivo e o Mandatory Access Control (MAC) ajudam a impedir que usuários não autorizados acessem dados enquanto o sistema operacional está ativo e o computador está ligado. No entanto, as permissões impostas pelo sistema operacional são irrelevantes se um invasor tiver acesso físico a um computador e puder mover o disco rígido do computador para outro sistema para copiar e analisar os dados.

Independentemente de como um invasor pode ter acesso a um disco rígido ou um computador desligado, os subsistemas criptográficos baseados em GEOM incorporados ao FreeBSD são capazes de proteger os dados nos sistemas de arquivos do computador contra atacantes super motivados com recursos significativos. Ao contrário dos métodos de criptografia que criptografam arquivos individuais, os utilitários incorporados `gbde` e `geli` podem ser usados ​​para criptografar de forma transparente sistemas de arquivos inteiros. Nenhum dado aberto sequer toca na bandeja do disco rígido.

Este capítulo demonstra como criar um sistema de arquivos criptografado no FreeBSD. Primeiro ele demonstra o processo usando o `gbde` e depois demonstra o mesmo exemplo usando `geli`.

### 17.12.1. Criptografia de Disco com gbde

O objetivo do utilitário gbde(4) é fornecer um desafio formidável para que um invasor que tenha acesso ao conteúdo de um dispositivo de armazenamento frio. No entanto, se o computador for comprometido enquanto estiver em funcionamento e o dispositivo de armazenamento estiver ativamente conectado, ou se o invasor tiver acesso a uma frase secreta válida, ele não oferecerá proteção ao conteúdo do dispositivo de armazenamento. Portanto, é importante fornecer segurança física enquanto o sistema está em execução e proteger a frase secreta usada pelo mecanismo de criptografia.

Este recurso oferece várias barreiras para proteger os dados armazenados em cada setor de disco. Ele criptografa o conteúdo de um setor de disco usando o AES de 128 bits no modo CBC. Cada setor no disco é criptografado com uma chave AES diferente. Para obter mais informações sobre o design criptográfico, incluindo como as chaves do setor são derivadas da frase secreta fornecida pelo usuário, consulte gbde(4).

O FreeBSD fornece um módulo do kernel para gbde, que pode ser carregado com este comando:

    # kldload geom_bde

Se estiver usando um arquivo de configuração de kernel personalizado, certifique-se de que ele contenha esta linha:

`options GEOM_BDE`

O exemplo a seguir demonstra a adição de um novo disco rígido a um sistema que conterá uma única partição criptografada que será montada como `/private`.

Procedimento 17.3. Criptografando uma Partição com gbde

1. Adicione o Novo Disco Rígido

   Instale a nova unidade no sistema, conforme explicado em Seção 17.2, “Adicionando Discos”. Para propósitos deste exemplo, uma nova partição de disco rígido foi adicionada como `/dev/ad4s1c` e `/dev/ad0s1`*`` representa o existente partições padrão do FreeBSD.

       # ls /dev/ad*
       /dev/ad0        /dev/ad0s1b     /dev/ad0s1e     /dev/ad4s1
       /dev/ad0s1      /dev/ad0s1c     /dev/ad0s1f     /dev/ad4s1c
       /dev/ad0s1a     /dev/ad0s1d     /dev/ad4

2. Criar um diretório para conter os arquivos de lock do `gbde`

       # mkdir /etc/gbde

   O arquivo de lock gbde contém informações que o gbde requer para acessar partições criptografadas. Sem acesso ao arquivo de lock, o gbde não poderá descriptografar os dados contidos na partição criptografada sem intervenção manual significativa que não seja suportada pelo software. Cada partição criptografada usa um arquivo de lock separado.

3. Inicialize a Partição `gbde`

   Uma partição gbde deve ser inicializada antes de poder ser usada. Essa inicialização precisa ser executada apenas uma vez. Esse comando abrirá o editor padrão, para definir várias opções de configuração em um modelo. Para uso com o sistema de arquivos UFS, defina o sector_size como 2048:

       # gbde init /dev/ad4s1c -i -L /etc/gbde/ad4s1c.lock
       # $FreeBSD: head/pt_BR.ISO8859-1/books/handbook/book.xml 53285 2019-07-30 23:45:23Z dbaio $
       #
       # Sector size is the smallest unit of data which can be read or written.
       # Making it too small decreases performance and decreases available space.
       # Making it too large may prevent filesystems from working.  512 is the
       # minimum and always safe.  For UFS, use the fragment size
       #
       sector_size	=	2048
       [...]

   Depois que a edição for salva, o usuário será solicitado a digitar duas vezes a frase secreta usada para proteger os dados. A frase secreta deve ser a mesma em ambas as vezes. A capacidade de gbde de proteger os dados depende inteiramente da qualidade da frase secreta. Para obter dicas sobre como selecionar uma frase secreta que seja fácil de lembrar, consulte http://world.std.com/~reinhold/diceware.htm.

   Essa inicialização cria um arquivo de lock para a partição do gbde. Neste exemplo, ele é armazenado como `/etc/gbde/ad4s1c.lock`. Os arquivos de lock devem terminar em “.lock” para serem corretamente detectados pelo script de inicialização do `/etc/rc.d/gbde`.

   ### Cuidado:

   Arquivos de lock devem ter backups junto com o conteúdo de qualquer partição criptografada. Sem o arquivo de lock, o proprietário legítimo não poderá acessar os dados na partição criptografada.

4. Anexando a Partição Criptografada ao Kernel

       # gbde attach /dev/ad4s1c -l /etc/gbde/ad4s1c.lock

   Este comando solicitará a entrada da senha que foi selecionada durante a inicialização da partição criptografada. O novo dispositivo criptografado aparecerá em `/dev` como `/dev/device_name.bde`:

       # ls /dev/ad*
       /dev/ad0        /dev/ad0s1b     /dev/ad0s1e     /dev/ad4s1
       /dev/ad0s1      /dev/ad0s1c     /dev/ad0s1f     /dev/ad4s1c
       /dev/ad0s1a     /dev/ad0s1d     /dev/ad4        /dev/ad4s1c.bde

5. Criando um Sistema de Arquivos no Dispositivo Criptografado

   Uma vez que o dispositivo criptografado tenha sido anexado ao kernel, um sistema de arquivos pode ser criado no dispositivo. Este exemplo cria um sistema de arquivos UFS com atualizações soft ativadas. Certifique-se de especificar a partição que possui uma extensão ``*`.bde`:

       # newfs -U /dev/ad4s1c.bde

6. Montando a Partição Criptografada

   Crie um ponto de montagem e monte o sistema de arquivos criptografados:

       # mkdir /private
       # mount /dev/ad4s1c.bde /private

7. Verificar se o sistema de arquivos criptografados está disponível

   O sistema de arquivos criptografados agora deve estar visível e disponível para uso:

       % df -H
       Filesystem        Size   Used  Avail Capacity  Mounted on
       /dev/ad0s1a      1037M    72M   883M     8%    /
       /devfs            1.0K   1.0K     0B   100%    /dev
       /dev/ad0s1f       8.1G    55K   7.5G     0%    /home
       /dev/ad0s1e      1037M   1.1M   953M     0%    /tmp
       /dev/ad0s1d       6.1G   1.9G   3.7G    35%    /usr
       /dev/ad4s1c.bde   150G   4.1K   138G     0%    /private

Após cada inicialização, todos os sistemas de arquivos criptografados devem ser reconectados manualmente ao kernel, verificados quanto a erros e montados antes que os sistemas de arquivos possam ser usados. Para configurar estas etapas, adicione as seguintes linhas ao arquivo `/etc/rc.conf`:

    gbde_autoattach_all="YES"
    gbde_devices="ad4s1c"
    gbde_lockdir="/etc/gbde"

Isso requer que a frase secreta seja inserida no console no momento da inicialização. Depois de digitar a senha correta, a partição criptografada será montada automaticamente. Opções adicionais de inicialização do gbde estão disponíveis e listadas em rc.conf(5).

### Nota:

O sysinstall é incompatível com os dispositivos criptografados com gbde. Todos os dispositivos `*.bde` devem ser desanexado do kernel antes de iniciar o sysinstall ou ele irá travar durante a análise inicial dos dispositivos. Para desanexar o dispositivo criptografado usado no exemplo, use o seguinte comando:

    # gbde detach /dev/ad4s1c

### 17.12.2. Criptografia de Disco com `geli`

Contribuido por Daniel Gerzo.

Uma classe criptográfica alternativa GEOM está disponível usando `geli`. Este utilitário de controle adiciona alguns recursos e usa um esquema diferente para fazer trabalho criptográfico. Ele fornece os seguintes recursos:

- Utiliza o framework crypto(9) e usa automaticamente o hardware criptográfico quando ele está disponível.

- Suporta vários algoritmos criptográficos, como AES, Blowfish e 3DES.

- Permite que a partição raiz seja criptografada. A frase secreta usada para acessar a partição root criptografada será solicitada durante a inicialização do sistema.

- Permite o uso de duas chaves independentes.

- É rápido, pois executa criptografia simples de setor a setor.

- Permite backup e restauração de chaves mestras. Se um usuário destruir suas chaves, ainda é possível obter acesso aos dados restaurando as chaves do backup.

- Permite que um disco seja anexado com uma chave única aleatória que é útil para partições swap e sistemas de arquivos temporários.

Mais recursos e exemplos de uso podem ser encontrados em geli(8).

O exemplo a seguir descreve como gerar um arquivo de chave que será usado como parte da chave mestra para o provedor criptografado montado em `/private`. O arquivo chave fornecerá alguns dados aleatórios usados ​​para criptografar a chave mestra. A chave mestra também será protegida por uma frase secreta. O tamanho do setor do provedor será de 4kB. O exemplo descreve como se conectar ao provedor `geli`, criar um sistema de arquivos, montá-lo, trabalhar com ele e, finalmente, como desanexá-lo.

Procedimento 17.4. Criptografando uma Partição com `geli`

1. Carregando o suporte ao `geli`

   O suporte para `geli` está disponível como um módulo de kernel carregável. Para configurar o sistema para carregar automaticamente o módulo no momento da inicialização, adicione a seguinte linha ao arquivo `/boot/loader.conf`:

       geom_eli_load="YES"

   Para carregar o módulo do kernel agora:

       # kldload geom_eli

   Para um kernel customizado, assegure-se de que o arquivo de configuração do kernel contenha estas linhas:

       options GEOM_ELI
       device crypto

2. Gerando a Chave Mestra

   Os seguintes comandos geram uma chave mestra (`/root/da2.key`) que é protegida com uma frase secreta. A fonte de dados para o arquivo de chave é `/dev/random` e o tamanho do setor do provedor (`/dev/da2.eli`) é de 4kB, pois um tamanho de setor maior fornece melhor desempenho:

       # dd if=/dev/random of=/root/da2.key bs=64 count=1
       # geli init -s 4096 -K /root/da2.key /dev/da2
       Enter new passphrase:
       Reenter new passphrase:

   Não é obrigatório o uso de uma frase secreta e de um arquivo de chave, pois cada método de proteger a chave mestra pode ser usado isoladamente.

   Se o arquivo de chave é dado como “-”, a entrada padrão será usada. Por exemplo, este comando gera três arquivos principais:

       # cat keyfile1 keyfile2 keyfile3 | geli init -K - /dev/da2

3. Anexando o Provedor com a Chave Gerada

   Para anexar o provedor, especifique o arquivo de chave, o nome do disco e a frase secreta:

       # geli attach -k /root/da2.key /dev/da2
       Enter passphrase:

   Isso cria um novo dispositivo com uma extensão `.eli`:

       # ls /dev/da2*
       /dev/da2  /dev/da2.eli

4. Criando o Novo Sistema de Arquivos

   Em seguida, formate o dispositivo com o sistema de arquivos UFS e monte-o em um ponto de montagem existente:

       # dd if=/dev/random of=/dev/da2.eli bs=1m
       # newfs /dev/da2.eli
       # mount /dev/da2.eli /private

   O sistema de arquivos criptografado agora deve estar disponível para uso:

       # df -H
       Filesystem     Size   Used  Avail Capacity  Mounted on
       /dev/ad0s1a    248M    89M   139M    38%    /
       /devfs         1.0K   1.0K     0B   100%    /dev
       /dev/ad0s1f    7.7G   2.3G   4.9G    32%    /usr
       /dev/ad0s1d    989M   1.5M   909M     0%    /tmp
       /dev/ad0s1e    3.9G   1.3G   2.3G    35%    /var
       /dev/da2.eli   150G   4.1K   138G     0%    /private

Uma vez que o trabalho na partição criptografada é feito, e a partição `/private` não é mais necessária, é prudente colocar o dispositivo no armazenamento frio desmontando e desanexando a partição `geli` criptografada do kernel:

    # umount /private
    # geli detach da2.eli

Um script `rc.d` é fornecido para simplificar a montagem de dispositivos criptografados `geli` no momento da inicialização. Para este exemplo, adicione estas linhas ao arquivo `/etc/rc.conf`:

    geli_devices="da2"
    geli_da2_flags="-k /root/da2.key"

Isto configura o `/dev/da2` como um provedor `geli` com uma chave mestra de `/root/da2.key`. O sistema irá desanexando automaticamente o provedor do kernel antes que o sistema seja desligado. Durante o processo de inicialização, o script solicitará a frase secreta antes de conectar o provedor. Outras mensagens do kernel podem ser mostradas antes e depois do prompt da frase secreta. Se o processo de inicialização parecer travar, procure cuidadosamente o prompt de senha entre as outras mensagens. Depois que a frase secreta correta é inserida, o provedor é anexado. O sistema de arquivos é então montado, normalmente por uma entrada em `/etc/fstab`. Consulte Seção 3.7, “Montando e Desmontando Sistemas de Arquivos” para obter instruções sobre como configurar um sistema de arquivos para montar no momento da inicialização.

Anterior | Acima | Próxima
17.11. Cotas de Disco | Principal | 17.13. Criptografando Swap

All FreeBSD documents are available for download at https://download.freebsd.org/ftp/doc/

Questions that are not answered by the documentation may be sent to <freebsd-questions@FreeBSD.org>.
Send questions about this document to <freebsd-doc@FreeBSD.org>.