Docker: Corrija Vulnerabilidades de Imagens com Trivy e Copa

As imagens de contêiner Docker frequentemente contêm vulnerabilidades de segurança herdadas dos pacotes do sistema operacional base. Em vez de reconstruir as imagens do zero, você pode usar o Trivy para escanear vulnerabilidades e o Copa para corrigi-las diretamente. Este tutorial demonstra como identificar e corrigir vulnerabilidades de contêiner em sistemas Ubuntu, Debian, RHEL, CentOS e Fedora usando essas duas poderosas ferramentas de código aberto.

Neste tutorial você aprenderá:

Como instalar o scanner de vulnerabilidades Trivy no Ubuntu/Debian
Como instalar a ferramenta de correção de contêiner Copa
Como escanear imagens Docker em busca de vulnerabilidades do sistema operacional
Como corrigir automaticamente vulnerabilidades de contêiner
Como verificar se imagens corrigidas estão livres de vulnerabilidades

Resumo do artigo: Faça a varredura de imagens Docker em busca de vulnerabilidades com o Trivy e corrija-as automaticamente usando o Copa.

Passo	Comando/Ação
1. Escanear imagem	`sudo trivy image --vuln-type os --ignore-unfixed IMAGE_NAME`
2. Exportar relatório JSON	`trivy image --vuln-type os --ignore-unfixed -f json -o report.json IMAGE_NAME`
3. Iniciar BuildKit	`sudo docker run --detach --rm --privileged -p 127.0.0.1:8888:8888/tcp --name buildkitd --entrypoint buildkitd moby/buildkit:v0.11.4 --addr tcp://0.0.0.0:8888`
4. Imagem do patch	`sudo copa patch -i IMAGE_NAME -r report.json -t patched -a tcp://0.0.0.0:8888`

Passo 1: Instale o Scanner de Vulnerabilidades Trivy

Trivy é um scanner de vulnerabilidades de código aberto desenvolvido pela Aqua Security. Ele detecta vulnerabilidades em pacotes do sistema operacional, dependências de aplicativos e imagens de containers.

Ubuntu/Debian

Instale as dependências: Primeiro instale os pacotes wget e gnupg necessários para adicionar o repositório:
```
$ sudo apt-get install wget gnupg -y
```

Adicionar chave GPG do Trivy: Baixe e adicione a chave de assinatura do repositório do Trivy:

$ wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | gpg --dearmor | sudo tee /usr/share/keyrings/trivy.gpg > /dev/null

Adicionar repositório Trivy: Adicione o repositório oficial do Trivy à sua lista de fontes:

$ echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] https://aquasecurity.github.io/trivy-repo/deb generic main" | sudo tee -a /etc/apt/sources.list.d/trivy.list

Instale o Trivy: Atualize a lista de pacotes e instale o Trivy:
```
$ sudo apt-get update
$ sudo apt-get install trivy -y
```

RHEL/CentOS/Fedora

Adicionar repositório Trivy: Crie o arquivo do repositório Trivy:

# sudo tee /etc/yum.repos.d/trivy.repo << 'EOF'
[trivy]
name=Trivy repository
baseurl=https://aquasecurity.github.io/trivy-repo/rpm/releases/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://aquasecurity.github.io/trivy-repo/rpm/public.key
EOF

Instale o Trivy: Use dnf ou yum para instalar:
```
# sudo dnf install trivy -y
```

Verifique a instalação conferindo a versão:

$ trivy --version

Passo 2: Instale a Ferramenta de Patching Copa

Copa (Copacetic) é um projeto sandbox da CNCF que aplica patches em imagens de contêiner diretamente, sem precisar de uma reconstrução completa. Ele utiliza relatórios de vulnerabilidades de scanners como o Trivy para aplicar atualizações de segurança. O Copa é distribuído como um único binário que funciona em todas as distribuições Linux.

Baixar binário do Copa: Obtenha o binário pré-compilado na página oficial de lançamentos do Copa no GitHub:
```
$ wget https://github.com/project-copacetic/copacetic/releases/download/v0.9.0/copa_0.9.0_linux_amd64.tar.gz
```
Extraia o arquivo: Descompacte o tarball baixado:
```
$ tar -xzf copa_0.9.0_linux_amd64.tar.gz
```
Instale o Copa: Mova o binário para o caminho do seu sistema:
```
$ sudo mv copa /usr/local/bin/
```
Verificar instalação: Confirme se o Copa está instalado corretamente:
```
$ copa --version
```

Passo 3: Verificar a Imagem do Contêiner em Busca de Vulnerabilidades

Antes de aplicar o patch, você precisa identificar vulnerabilidades na sua imagem de contêiner. Os seguintes passos usam linuxconfig/instantprivacy como exemplo – substitua pelo nome da sua própria imagem.

Baixar a imagem do contêiner: Faça o download da imagem que você deseja escanear:
```
$ sudo docker pull linuxconfig/instantprivacy
```
Verificar vulnerabilidades: Execute o Trivy para verificar vulnerabilidades no nível do sistema operacional. A flag --ignore-unfixed exclui vulnerabilidades sem correções disponíveis:
```
$ sudo trivy image --vuln-type os --ignore-unfixed linuxconfig/instantprivacy
```

Exportar relatório JSON: Copa requer os resultados da varredura em formato JSON:

$ trivy image --vuln-type os --ignore-unfixed -f json -o instantprivacy.json linuxconfig/instantprivacy

Passo 4: Atualizar a Imagem do Contêiner com o Copa

O Copa usa o BuildKit para aplicar patches às imagens de contêiner.

Iniciar contêiner BuildKit: Execute o BuildKit como um contêiner privilegiado:

$ sudo docker run --detach --rm --privileged \
  -p 127.0.0.1:8888:8888/tcp \
  --name buildkitd \
  --entrypoint buildkitd \
  moby/buildkit:v0.11.4 \
  --addr tcp://0.0.0.0:8888

Verifique se o BuildKit está em execução: Confirme se o contêiner foi iniciado com sucesso:
```
$ sudo docker ps
```
Atualize a imagem do contêiner: Use o Copa para aplicar patches de segurança. A flag -t especifica a tag para a imagem atualizada:
```
$ sudo copa patch \
  -i docker.io/linuxconfig/instantprivacy \
  -r instantprivacy.json \
  -t patched \
  -a tcp://0.0.0.0:8888
```
Copa baixa atualizações de segurança e cria uma nova camada de imagem com os patches aplicados. A imagem com patches será marcada como linuxconfig/instantprivacy:patched.

Passo 5: Verificar a Imagem Corrigida

Escaneie a imagem corrigida: Confirme se todas as vulnerabilidades foram resolvidas:

$ sudo trivy image --vuln-type os --ignore-unfixed linuxconfig/instantprivacy:patched

Teste a imagem corrigida: Verifique se a imagem corrigida funciona corretamente:

$ sudo docker run --name=instantprivacy -d -p 8118:8118 linuxconfig/instantprivacy:patched
$ export http_proxy="http://localhost:8118"
$ curl api.ipify.org
45.84.107.174

Limpeza: Pare o contêiner BuildKit quando terminar:
```
$ sudo docker stop buildkitd
```

Conclusão

Você escaneou com sucesso uma imagem de contêiner Docker em busca de vulnerabilidades de segurança usando o Trivy e as corrigiu automaticamente com o Copa. Essa abordagem é mais rápida do que reconstruir imagens do zero e adiciona apenas uma única camada de correção, preservando a estrutura original da imagem. Para ambientes de produção, integre essas ferramentas em seu pipeline de CI/CD para escanear e corrigir automaticamente as imagens de contêiner antes do deployment. Para mais informações, consulte a documentação oficial do Trivy e o site do projeto Copa.

Perguntas Frequentes

Que tipos de vulnerabilidades o Copa pode corrigir? O Copa só corrige vulnerabilidades em pacotes de nível de sistema operacional (como pacotes Debian, Ubuntu, Alpine ou RHEL). Ele não consegue corrigir dependências de nível de aplicação, como pacotes npm, módulos Python pip ou módulos Go. Para esses casos, é necessário reconstruir a aplicação com as dependências atualizadas.
Por que eu preciso do BuildKit para executar o Copa? O Copa usa os recursos de diff e merge do BuildKit para criar uma nova camada de imagem contendo apenas os arquivos corrigidos. O BuildKit é executado como um contêiner com privilégios que lida com a manipulação de imagens em baixo nível. Sem o BuildKit, o Copa não pode aplicar patches ao sistema de arquivos do contêiner.
Posso atualizar imagens de registries privados? Sim, o Copa suporta registries privados. Você precisa se autenticar com docker login antes de executar o comando de atualização. O Copa usa suas credenciais do Docker para baixar a imagem base e enviar o resultado atualizado, se necessário.
O que acontece se o Copa não conseguir corrigir todas as vulnerabilidades? Algumas vulnerabilidades podem ainda não ter correções disponíveis. A opção --ignore-unfixed no Trivy as exclui do relatório. O Copa irá corrigir tudo o que tiver uma correção disponível. Execute o Trivy novamente sem --ignore-unfixed para ver todas as vulnerabilidades, incluindo aquelas que ainda aguardam patches.
Como atualizo o Copa para a versão mais recente? Baixe a versão mais recente na página de lançamentos do Copa no GitHub e substitua o binário em /usr/local/bin/. Verifique a versão atual com copa --version.