Tutorial: Encontrar e corrigir dependências vulneráveis com govulncheck
Govulncheck é uma ferramenta de baixo ruído que ajuda você a encontrar e corrigir dependências vulneráveis nos seus projetos Go. Ela faz isso analisando as dependências do projeto em busca de vulnerabilidades conhecidas e, em seguida, identificando qualquer chamada direta ou indireta a essas vulnerabilidades no seu código.
Neste tutorial, você vai aprender a usar o govulncheck para analisar um programa simples em busca de vulnerabilidades. Você também vai aprender a priorizar e avaliar vulnerabilidades, para concentrar seus esforços primeiro nas mais importantes.
Para saber mais sobre o govulncheck, veja a documentação do govulncheck e este post do blog sobre gestão de vulnerabilidades em Go. Também adoraríamos ouvir o seu feedback.
Pré-requisitos
- Go. Recomendamos usar a versão mais recente do Go para seguir este tutorial. Para as instruções de instalação, veja Instalando o Go.
- Um editor de código. Qualquer editor que você tenha vai funcionar bem.
- Um terminal de linha de comando. O Go funciona bem em qualquer terminal no Linux e no Mac, e no PowerShell ou no cmd do Windows.
O tutorial vai guiar você pelos seguintes passos:
- Criar um módulo Go de exemplo com uma dependência vulnerável
- Instalar e executar o govulncheck
- Avaliar as vulnerabilidades
- Atualizar as dependências vulneráveis
Criar um módulo Go de exemplo com uma dependência vulnerável
Passo 1. Para começar, crie uma nova pasta chamada vuln-tutorial e inicialize um módulo Go.
(Se você é novo nos módulos Go, veja go.dev/doc/tutorial/create-module.
Por exemplo, a partir do seu diretório home, execute o seguinte:
$ mkdir vuln-tutorial
$ cd vuln-tutorial
$ go mod init vuln.tutorial
Passo 2. Crie um arquivo chamado main.go dentro da pasta vuln-tutorial e copie
o código a seguir para dentro dele:
package main
import (
"fmt"
"os"
"golang.org/x/text/language"
)
func main() {
for _, arg := range os.Args[1:] {
tag, err := language.Parse(arg)
if err != nil {
fmt.Printf("%s: error: %v\n", arg, err)
} else if tag == language.Und {
fmt.Printf("%s: undefined\n", arg)
} else {
fmt.Printf("%s: tag %s\n", arg, tag)
}
}
}
Este programa de exemplo recebe uma lista de tags de idioma como argumentos da linha de comando e imprime uma mensagem para cada tag, indicando se ela foi interpretada com sucesso, se a tag é indefinida ou se houve erro ao interpretá-la.
Passo 3. Execute go mod tidy, que vai preencher o arquivo go.mod com todas as
dependências exigidas pelo código que você adicionou em main.go no passo anterior.
Na pasta vuln-tutorial, execute:
$ go mod tidy
Você deve ver esta saída:
go: finding module for package golang.org/x/text/language
go: downloading golang.org/x/text v0.9.0
go: found golang.org/x/text/language in golang.org/x/text v0.9.0
Passo 4. Abra o seu arquivo go.mod para verificar se ele está assim:
module vuln.tutorial
go 1.20
require golang.org/x/text v0.9.0
Passo 5. Faça o downgrade da versão de golang.org/x/text para a v0.3.5, que contém
vulnerabilidades conhecidas. Execute:
$ go get golang.org/x/text@v0.3.5
Você deve ver esta saída:
go: downgraded golang.org/x/text v0.9.0 => v0.3.5
O arquivo go.mod agora deve estar assim:
module vuln.tutorial
go 1.20
require golang.org/x/text v0.3.5
Agora, vamos ver o govulncheck em ação.
Instalar e executar o govulncheck
Passo 6. Instale o govulncheck com o comando go install:
$ go install golang.org/x/vuln/cmd/govulncheck@latest
Passo 7. Na pasta que você quer analisar (neste caso, vuln-tutorial), execute:
$ govulncheck ./...
Você deve ver esta saída:
govulncheck is an experimental tool. Share feedback at https://go.dev/s/govulncheck-feedback.
Using go1.20.3 and govulncheck@v0.0.0 with
vulnerability data from https://vuln.go.dev (last modified 2023-04-18 21:32:26 +0000 UTC).
Scanning your code and 46 packages across 1 dependent module for known vulnerabilities...
Your code is affected by 1 vulnerability from 1 module.
Vulnerability #1: GO-2021-0113
Due to improper index calculation, an incorrectly formatted
language tag can cause Parse to panic via an out of bounds read.
If Parse is used to process untrusted user inputs, this may be
used as a vector for a denial of service attack.
More info: https://pkg.go.dev/vuln/GO-2021-0113
Module: golang.org/x/text
Found in: golang.org/x/text@v0.3.5
Fixed in: golang.org/x/text@v0.3.7
Call stacks in your code:
main.go:12:29: vuln.tutorial.main calls golang.org/x/text/language.Parse
=== Informational ===
Found 1 vulnerability in packages that you import, but there are no call
stacks leading to the use of this vulnerability. You may not need to
take any action. See https://pkg.go.dev/golang.org/x/vuln/cmd/govulncheck
for details.
Vulnerability #1: GO-2022-1059
An attacker may cause a denial of service by crafting an
Accept-Language header which ParseAcceptLanguage will take
significant time to parse.
More info: https://pkg.go.dev/vuln/GO-2022-1059
Found in: golang.org/x/text@v0.3.5
Fixed in: golang.org/x/text@v0.3.8
Interpretando a saída
*Observação: se você não estiver usando a versão mais recente do Go, pode ver vulnerabilidades adicionais da biblioteca padrão.
Nosso código é afetado por uma vulnerabilidade,
GO-2021-0113, porque ele chama diretamente
a função Parse de golang.org/x/text/language em uma versão vulnerável
(v0.3.5).
Outra vulnerabilidade, GO-2022-1059,
existe no módulo golang.org/x/text na v0.3.5. No entanto, ela é reportada como
“Informational” porque o nosso código nunca chama (direta ou indiretamente) nenhuma
das funções vulneráveis dela.
Agora, vamos avaliar as vulnerabilidades e decidir qual ação tomar.
Avaliar as vulnerabilidades
a. Avalie as vulnerabilidades.
Primeiro, leia a descrição da vulnerabilidade e determine se ela realmente se aplica ao seu código e ao seu caso de uso. Se precisar de mais informações, acesse o link “More info”.
Pela descrição, a vulnerabilidade GO-2021-0113 pode causar um panic quando
Parse é usada para processar entradas de usuários não confiáveis. Vamos supor
que o nosso programa deva suportar entradas não confiáveis e que estamos
preocupados com negação de serviço, então a vulnerabilidade provavelmente se aplica.
A GO-2022-1059 provavelmente não afeta o nosso código, porque ele não chama nenhuma das funções vulneráveis desse relatório.
b. Decida uma ação.
Para mitigar a GO-2021-0113, temos algumas opções:
- Opção 1: Atualizar para uma versão corrigida. Se houver uma correção disponível, podemos remover a dependência vulnerável atualizando para uma versão corrigida do módulo.
- Opção 2: Parar de usar os símbolos vulneráveis. Poderíamos optar por remover todas as chamadas à função vulnerável no nosso código. Teríamos de encontrar uma alternativa ou implementá-la nós mesmos.
Neste caso, há uma correção disponível, e a função Parse é parte essencial do
nosso programa. Vamos atualizar a nossa dependência para a versão indicada em
“Fixed in”, a v0.3.7.
Decidimos adiar a correção da vulnerabilidade informativa GO-2022-1059, mas, como ela está no mesmo módulo que a GO-2021-0113, e como a versão corrigida dela é a v0.3.8, podemos remover as duas de uma só vez atualizando para a v0.3.8.
Atualizar as dependências vulneráveis
Felizmente, atualizar dependências vulneráveis é bem simples.
Passo 8. Atualize golang.org/x/text para a v0.3.8:
$ go get golang.org/x/text@v0.3.8
Você deve ver esta saída:
go: upgraded golang.org/x/text v0.3.5 => v0.3.8
(Observe que poderíamos ter escolhido atualizar para latest, ou para qualquer
outra versão posterior à v0.3.8.)
Passo 9. Agora, execute o govulncheck novamente:
$ govulncheck ./...
Você verá esta saída:
govulncheck is an experimental tool. Share feedback at https://go.dev/s/govulncheck-feedback.
Using go1.20.3 and govulncheck@v0.0.0 with
vulnerability data from https://vuln.go.dev (last modified 2023-04-06 19:19:26 +0000 UTC).
Scanning your code and 46 packages across 1 dependent module for known vulnerabilities...
No vulnerabilities found.
Por fim, o govulncheck confirma que nenhuma vulnerabilidade foi encontrada.
Ao analisar regularmente as suas dependências com o comando govulncheck, você protege a sua base de código identificando, priorizando e corrigindo vulnerabilidades.