Configurar a verificação de dependências

A verificação de dependência no GitHub Advanced Security for Azure DevOps deteta os componentes de código aberto usados em seu código-fonte e deteta se há alguma vulnerabilidade associada. Qualquer vulnerabilidade encontrada de componentes de código aberto é sinalizada como um alerta. Você precisará do GitHub Advanced Security for Azure DevOps ou, se estiver usando a experiência autônoma, do GitHub Code Security for Azure DevOps habilitado.

O GitHub Advanced Security for Azure DevOps funciona com o Azure Repos. Para usar a Segurança Avançada do GitHub com repositórios do GitHub, consulte Segurança Avançada do GitHub.

Pré-requisitos

Para obter mais informações sobre permissões de Segurança Avançada, consulte Gerenciar permissões de Segurança Avançada.

Sobre a verificação de dependências

A verificação de dependência gera um alerta para qualquer componente de código aberto, direto ou transitivo, considerado vulnerável do qual seu código depende. As vulnerabilidades diretas são as bibliotecas que seu código usa diretamente. Dependências transitivas são as bibliotecas ou outros softwares que as dependências diretas usam.

Saiba mais sobre a deteção de dependências

Um novo instantâneo de seus componentes é armazenado sempre que o gráfico de dependência de um repositório é alterado e depois que um pipeline que contém a tarefa de verificação de dependência é executado.

Para cada componente vulnerável detetado em uso, o componente e a vulnerabilidade são listados no log de compilação e exibidos como um alerta na guia Segurança Avançada. Somente os avisos revisados pelo GitHub e adicionados ao Banco de Dados de Avisos do GitHub criam um alerta de verificação de dependência. O registo de compilação inclui um link para o alerta individual para investigação mais aprofundada. Para obter mais informações sobre os detalhes do alerta, consulte Corrigindo alertas de verificação de dependência.

O log de compilação também contém informações básicas sobre cada vulnerabilidade detetada. Esses detalhes incluem a gravidade, o componente afetado, o título da vulnerabilidade e a CVE associada.

Para obter uma lista de ecossistemas e versões de componentes suportados, consulte Ecossistemas de pacotes suportados.

Saiba mais sobre alertas de verificação de dependência

A guia Segurança Avançada em Repos no Azure DevOps é o hub para exibir os alertas de segurança, que, por padrão, mostra alertas de análise de dependências. Você pode filtrar por ramificação, pipeline, pacote e gravidade. Você pode selecionar um alerta para obter mais detalhes, incluindo orientação de correção. No momento, o hub de alertas não exibe alertas para análises concluídas em ramificações de PR.

Quando um pacote vulnerável é detetado em seu repositório, a correção de alertas de verificação de dependência geralmente envolve a atualização para uma versão superior do pacote ou a remoção de um pacote ofensivo. Este conselho é válido tanto para dependências diretas como transitivas (ou indiretas). A visualização padrão no separador Segurança Avançada mostra os alertas ativos para a ramificação padrão do seu repositório.

Não há impacto nos resultados se os fluxos de trabalho ou as ramificações forem renomeados - pode demorar até 24 horas para que o novo nome seja exibido.

O estado de um alerta é atualizado automaticamente para Closed quando o componente vulnerável não é mais detetado na compilação mais recente para todos os pipelines onde a tarefa de verificação de dependência está instalada. Para visualizar os alertas resolvidos, utilize o State filtro na barra de ferramentas principal e selecione Closed.

Se você desativar a Segurança Avançada para seu repositório, perderá o acesso aos resultados na guia Segurança Avançada e na tarefa de compilação. A tarefa de compilação não falha, mas todos os resultados das compilações executadas com a tarefa enquanto a Segurança Avançada está desativada ficam ocultos e não são mantidos.

Detalhes do alerta

Você também pode detalhar detalhes sobre um alerta clicando em um alerta específico e em orientações de correção.

Deteções

Os pipelines listados na aba Deteções são aqueles onde o componente vulnerável foi encontrado. Cada linha detalha a compilação mais recente do pipeline afetado e a data em que o pacote foi introduzido pela primeira vez. Se o pacote vulnerável for corrigido em alguns pipelines, mas não em todos, verás linhas parcialmente corrigidas.

Depois que um alerta é resolvido, o alerta é movido automaticamente para o Closed estado e o pipeline de execução mais recente na guia Deteções exibe uma marca de seleção verde, o que significa que o código que contém o componente atualizado foi executado nesse pipeline:

Gravidade

O GitHub Advisory Database fornece uma pontuação CVSS, que é então traduzida em uma gravidade baixa, média, alta ou crítica para um alerta por meio das seguintes diretrizes:

Encontrar detalhes

Duas seções são comumente encontradas em Detalhes da Pesquisa: o pacote vulnerável e a dependência raiz. O pacote vulnerável é o componente potencialmente vulnerável. A seção de dependência raiz contém componentes de nível superior que são responsáveis pela cadeia de dependência que leva a uma vulnerabilidade.

Se o pacote vulnerável for referenciado apenas como uma dependência direta, você verá apenas a seção "pacote vulnerável".

Se o pacote vulnerável for referenciado como uma dependência direta e transitiva, o pacote será mostrado na seção "pacote vulnerável" e "dependência raiz".

Se o pacote vulnerável for referenciado apenas como uma dependência transitiva, o pacote será mostrado na seção "pacote vulnerável" e as dependências raiz que fazem referência ao pacote vulnerável serão mostradas na seção "dependência raiz".

Gerir alertas de varredura de dependências

Visualizando alertas para um repositório

Por padrão, a página de alertas mostra os resultados da verificação de dependência para a ramificação padrão do repositório.

O status de um alerta reflete o estado da ramificação padrão e do pipeline de execução mais recente, mesmo que o alerta exista em outras ramificações e pipelines.

Corrigindo alertas de análise de dependência

Uma dependência direta é um componente que você tem em seu repositório. Uma dependência transitiva ou indireta é um componente que é usado por uma dependência direta. Seu projeto ainda está vulnerável, independentemente de a vulnerabilidade ser encontrada em uma dependência direta ou transitiva.

Corrigir uma dependência transitiva vulnerável geralmente assume a forma de sobrescrever explicitamente a versão do componente vulnerável utilizada em cada dependência direta identificada. Depois que as dependências raiz atualizarem seu uso do componente vulnerável para uma versão segura, você poderá atualizar cada dependência raiz em vez de várias substituições individuais.

Atualizar dependências do Yarn/Npm

Hipoteticamente, digamos que este pacote tem duas vulnerabilidades. Um é para axios, uma dependência direta, e um é para acorn, uma dependência transitiva (também conhecida como dependência indireta ou dependência de dependência).

{
 "name": "my-package",
 "version": "1.0.0",
 "dependencies": {
   "axios": "0.18.0",
   "eslint": "5.16.0",
 }
}

A versão atual do axios tem uma vulnerabilidade de negação de serviço (DoS) com uma recomendação de atualização para v0.18.1 ou superior. Por ser uma dependência direta, tens controlo sobre a versão de axios que utilizas; tudo o que precisas de fazer é atualizar a versão de axios que importas. O atualizado package.json é semelhante a:

{
  "name": "my-package",
  "version": "1.0.0",
  "dependencies": {
    "axios": "0.19.2",
    "eslint": "5.16.0",
  }
}

Agora, a versão do eslint mostrada no package.json depende de uma versão do acorn que possui uma vulnerabilidade de negação de serviço por expressão regular, "Re-DoS", com a recomendação de atualizar para a versão 5.7.4, 6.4.1, 7.1.1 ou superior. Se receberes um alerta da ferramenta de análise de dependências, ele deverá informar a dependência raiz que requer a dependência vulnerável.

Fios

Se você estiver usando o Yarn, poderá usar o yarn why para encontrar a cadeia de dependência completa.

> $ yarn why acorn
 yarn why v1.22.4
 [1/4] Why do we have the module "acorn"...?
 [2/4] Initialising dependency graph...
 [3/4] Finding dependency...
 [4/4] Calculating file sizes...
 => Found "acorn@6.4.0"
 info Reasons this module exists
   - "eslint#espree" depends on it
   - Hoisted from "eslint#espree#acorn"
 info Disk size without dependencies: "1.09MB"
 info Disk size with unique dependencies: "1.09MB"
 info Disk size with transitive dependencies: "1.09MB"
 info Number of shared dependencies: 0
 Done in 0.30s.

A cadeia de dependência completa é eslint>espree>acorn. Depois de conhecer a cadeia de dependência, pode usar outra funcionalidade do Yarn, que são as "resoluções seletivas de dependências", para substituir a versão de acorn que está a ser utilizada.

Use o campo de resoluções em package.json para definir uma substituição de versão. Três métodos diferentes para substituir um pacote são mostrados, em ordem do pior para o melhor:

{
  "name": "yarn-resolutions",
  "version": "1.0.0",
  "license": "MIT",
  "dependencies": {
    "axios": "0.19.2",
    "eslint": "5.16.0"
  },
  "resolutions": {
    // DO NOT USE!
    "**/acorn": "6.4.1",
    // BETTER
    "eslint/**/acorn": "6.4.1",
    // BEST
    "eslint/espree/acorn": "6.4.1"
  }
}

O uso do**/acorn padrão substitui todas as utilizações do pacote acorn em todas as dependências. É perigoso e quebra em tempo de execução, por isso o removemos no Yarn v2.

O uso do padrão eslint/**/acorn substitui todas as utilizações do pacote acorn dentro do pacote eslint e de quaisquer pacotes dos quais ele dependa. É mais seguro do que sobrepor o pacote para todas as dependências, mas ainda pode apresentar alguns riscos se o grafo de dependências de um pacote for grande. Esse padrão é recomendado quando há muitos subpacotes que usam um pacote vulnerável e definir substituições para subpacotes individuais seria impraticável.

O uso do padrão eslint/espree/acorn substitui apenas o uso de acorn do pacote espree dentro do pacote eslint. Ele visa especificamente a cadeia de dependência vulnerável e é a maneira recomendada de substituir versões de pacote.

NPM

Se estiver a usar o npm 8.3 ou superior, pode usar o campo overrides no seu package.json

Adicione uma substituição se precisar fazer alterações específicas nas dependências transitivas. Por exemplo, pode ser necessário substituir a versão de uma dependência devido a um problema de segurança conhecido, substituir uma dependência existente por uma bifurcação ou garantir que a mesma versão de um pacote seja usada em todos os locais.

{
  "name": "npm-overrides",
  "version": "1.0.0",
  "license": "MIT",
  "dependencies": {
    "axios": "0.19.2",
    "eslint": "5.16.0"
  },
   "overrides":{
       "eslint": {
        "espree": {
          "acorn": "6.4.1"
        }
    }
   }
}

O exemplo de substituição mostrado demonstra o modo como o npm indica "sobrepor apenas o uso de acorn no pacote espree no pacote eslint". Isto destina-se especificamente à cadeia de dependências vulnerável e é a maneira recomendada de sobrepor versões de pacotes. As substituições são uma característica nativa do npm. Ele fornece uma maneira de substituir um pacote em sua árvore de dependência por outra versão ou outro pacote inteiramente.

Depois de definir as suas substituições, deve excluir o package-lock.json e o node_modules e executar o npm install novamente.

Você pode não definir uma substituição para um pacote do qual depende diretamente, a menos que a dependência e a substituição em si compartilhem exatamente a mesma especificação. Por exemplo, digamos que axios: "0.18.0" é vulnerável e estamos procurando atualizar para axios: "0.19.2". Altere diretamente a versão de dependência em vez de usar a substituição.

{
  "name": "npm-overrides",
  "version": "1.0.0",
  "license": "MIT",
  "dependencies": {
    "axios": "0.18.0"
  },
  "overrides": {
    // BAD, will throw an EOVERRIDE error
    // "axios": "0.19.2",
  }
}

Atualizar a versão da dependência sem definir uma sobreposição:

{
  "name": "npm-overrides",
  "version": "1.0.0",
  "license": "MIT",
  "dependencies": {
    "axios": "0.19.2"
  }
}

Atualizando dependências para o Maven

O mecanismo de resolução de dependência não é tão sofisticado quanto o usado no Yarn. Como resultado, você só pode ter uma única versão de uma dependência em um projeto. Para resolver esse problema, o Maven usa um algoritmo de "vitórias mais próximas". Ou seja, ele usa a versão da dependência mais próxima do seu projeto na árvore de dependências.

Por exemplo, você tem o seguinte gráfico de dependência:

your-project --- A:1.0.0 --- B:2.0.0
      \
       \__ B:1.0.0

your-project depende do A:1.0.0, que por sua vez depende, B:2.0.0 mas o seu projeto também tem uma dependência direta do B:1.0.0. Portanto, você tem duas versões diferentes da dependência B em seu gráfico de dependência, mas a versão 1.0.0 da dependência B vence por estar "mais próxima" do seu projeto.

Em alguns casos, esse cenário pode funcionar se as versões forem compatíveis. No entanto, se A:1.0.0 depender de algum recurso do B que só está disponível na versão 2.0.0 , então esse comportamento não funciona. Na pior das hipóteses, este projeto ainda pode ser compilado, mas falha em tempo de execução.

Vamos dar uma olhada em um exemplo do mundo real.

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.microsoft.customer360</groupId>
  <artifactId>maven-dependencies</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>maven-dependencies</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>com.fasterxml.jackson.jaxrs</groupId>
      <artifactId>jackson-jaxrs-json-provider</artifactId>
      <version>2.10.3</version>
    </dependency>
</project>

Digamos que a versão de com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider de que dependes depende de uma versão de com.fasterxml.jackson.core:jackson-databind que tenha uma vulnerabilidade de desserialização de dados não confiáveis.

Você pode verificar esta dependência usando o plugin de dependência Maven. Neste caso, você executaria mvn dependency:tree -Dincludes=com.fasterxml.jackson.core:jackson-databind e obteria a seguinte saída:

> $ mvn dependency:tree -Dincludes=com.fasterxml.jackson.core:jackson-databind
 [INFO] Scanning for projects...
 [INFO]
 [INFO] ------------< com.microsoft.customer360:maven-dependencies >------------
 [INFO] Building maven-dependencies 1.0-SNAPSHOT
 [INFO] --------------------------------[ jar ]---------------------------------
 [INFO]
 [INFO] --- maven-dependency-plugin:2.8:tree (default-cli) @ maven-dependencies ---
 [INFO] com.microsoft.customer360:maven-dependencies:jar:1.0-SNAPSHOT
 [INFO] \- com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider:jar:2.10.3:compile
 [INFO]    \- com.fasterxml.jackson.jaxrs:jackson-jaxrs-base:jar:2.10.3:compile
 [INFO]       \- com.fasterxml.jackson.core:jackson-databind:jar:2.10.3:compile
 [INFO] ------------------------------------------------------------------------
 [INFO] BUILD SUCCESS
 [INFO] ------------------------------------------------------------------------
 [INFO] Total time:  0.928 s
 [INFO] Finished at: 2020-04-27T14:30:55+02:00
 [INFO] ------------------------------------------------------------------------

Primeiro, verifique se há uma nova versão de com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider que não dependa de uma versão vulnerável de com.fasterxml.jackson.core:jackson-databind. Se sim, você pode atualizar com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider e parar por aí. Caso contrário, substitua a versão do com.fasterxml.jackson.core:jackson-databind.

Como mostrado no trecho de código, ao utilizar o Maven, o "mais próximo vence", então a solução passa por adicionar uma dependência direta em com.fasterxml.jackson.core:jackson-databind que resolva a vulnerabilidade.

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.microsoft.customer360</groupId>
  <artifactId>maven-dependencies</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>maven-dependencies</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>com.fasterxml.jackson.jaxrs</groupId>
      <artifactId>jackson-jaxrs-json-provider</artifactId>
      <version>2.10.3</version>
    </dependency>
    <!-- Dependency resolutions -->
    <!-- jackson-jaxrs-json-provider -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.10.4</version>
    </dependency>
  </dependencies>
</project>

Você pode verificar se a resolução funciona executando mvn dependency:tree -Dincludes=com.fasterxml.jackson.core:jackson-databind novamente.

$ mvn dependency:tree -Dincludes=com.fasterxml.jackson.core:jackson-databind
[INFO] Scanning for projects...
[INFO]
[INFO] ------------< com.microsoft.customer360:maven-dependencies >------------
[INFO] Building maven-dependencies 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-dependency-plugin:2.8:tree (default-cli) @ maven-dependencies ---
[INFO] com.microsoft.customer360:maven-dependencies:jar:1.0-SNAPSHOT
[INFO] \- com.fasterxml.jackson.core:jackson-databind:jar:2.9.10.4:compile
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  0.827 s
[INFO] Finished at: 2020-04-27T14:32:42+02:00
[INFO] ------------------------------------------------------------------------

Recomendamos que adiciones um comentário junto à resolução de dependências, para que qualquer pessoa que venha posteriormente saiba por que a dependência está lá. Ele pode ser removido uma vez que a dependência raiz usa a nova versão; caso contrário, você acumulará dependências.

Em um projeto real, adicione a dependência o mais alto possível na cadeia. Por exemplo, pode adicionar a resolução no arquivo POM pai, em vez de o fazer individualmente em cada arquivo POM do projeto.

Atualizando dependências para o NuGet

O algoritmo de resolução de dependência usado no NuGet é semelhante ao Maven, em que apenas uma única versão de uma dependência pode ser usada. No entanto, o NuGet não fixa versões de dependência.

Por exemplo, se você tiver uma dependência <PackageReference Include="A" Version="1.2.3" />, você pode esperar que este pacote seja equivalente a = 1.2.3, mas na verdade significa >= 1.2.3. Para fixar uma versão exata, deve usar Version="[1.2.3]". Para obter mais informações, consulte a documentação dos intervalos de versões do NuGet.

Além do comportamento de intervalo padrão, o NuGet restaura a versão mais baixa aplicável para satisfazer um intervalo. Esse comportamento significa que, em muitos casos, você precisa definir um intervalo.

Vamos dar uma olhada neste projeto de exemplo, que tem uma dependência de Microsoft.AspNetCore.App:

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <RootNamespace>NuGet.Dependencies</RootNamespace>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.14" />
  </ItemGroup>
</Project>

Depende de uma versão de Microsoft.AspNetCore.Http.Connections que seja vulnerável a uma vulnerabilidade de execução remota de código (RCE).

Primeiro, deve verificar se há uma versão atualizada de Microsoft.AspNetCore.App que depende de uma versão mais recente do Microsoft.AspNetCore.Http.Connections. Se sim, você pode atualizar Microsoft.AspNetCore.App e parar aqui. Se não, tens de substituir a versão de que Microsoft.AspNetCore.Http.Connections depende.

O NuGet não tem um equivalente integrado ao yarn why ou ao mvn dependency:tree, portanto, a maneira mais fácil de ver a árvore de dependências é frequentemente visitar nuget.org. Se visitar a página do NuGet para Microsoft.AspNetCore.App, verá que depende de Microsoft.AspNetCore.Http.Connectionsversion >= 1.0.4 && < 1.1.0. Ou, em um intervalo de versões do NuGet, a sintaxe representativa é [1.0.4,1.1.0).

A vulnerabilidade RCE em Microsoft.AspNetCore.Http.Connections foi corrigida na versão 1.0.15, então você precisa substituir o intervalo de versões a ser[1.0.15, 1.1.0).

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <RootNamespace>NuGet.Dependencies</RootNamespace>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.2.8" />
  </ItemGroup>

  <ItemGroup Label="Dependency Resolutions">
    <!-- Microsoft.AspNetCore.App -->
    <PackageReference Include="Microsoft.AspNetCore.Http.Connections" Version="[1.0.15,1.1.0)" />
  </ItemGroup>
</Project>

Recomendamos que você adicione um comentário perto da resolução de dependência para que qualquer pessoa que venha mais tarde saiba por que a dependência está lá. Ele pode ser removido quando a dependência raiz usa a nova versão. Caso contrário, você acumulará dependências.

E se não houver nenhuma correção disponível?

Quando nenhuma correção conhecida estiver disponível, as seguintes opções estarão disponíveis como outros métodos de correção até que um componente atualizado esteja disponível:

• Pare de usar o componente e remova-o do seu código - esta remoção é detetada na sua próxima compilação com a tarefa de verificação de dependência instalada
• Contribua com uma correção para o próprio componente. Se a sua organização tiver diretrizes específicas sobre contribuições de código aberto, siga essas diretrizes.
• Descartando o alerta. No entanto, alertas sem correção conhecida ainda podem representar uma ameaça à segurança da sua organização. Recomendamos que você não descarte um alerta apenas porque não há nenhuma correção conhecida.

Ignorar alertas de verificação de dependência

Para descartar um alerta, execute as seguintes etapas:

1. Aceda ao alerta que pretende fechar e clique no alerta.

2. Selecione o menu pendente Fechar alerta.

3. Se ainda não estiver selecionado, selecione Risco aceito ou Falso positivo como o motivo do fechamento.

4. Adicione um comentário opcional na caixa de texto Comentário.

5. Selecione Fechar para enviar e feche o alerta.

6. O estado de alerta muda de Aberto para Fechado e exibe o motivo da demissão.

   

Esta ação elimina o alerta em todas as filiais. Outras ramificações que contenham a mesma vulnerabilidade também serão descartadas. Qualquer notificação de alerta anteriormente descartada pode ser reaberta manualmente.

Gerenciando alertas de varredura de dependência em solicitações pull

Se forem criados alertas para novas alterações de código em uma solicitação pull, o alerta será relatado como uma anotação na seção de comentários da guia Visão geral da solicitação pull e como um alerta na guia Advanced Security repository. Uma nova entrada do seletor de ramificação está disponível para a ramificação de solicitação pull.

Você pode ver o manifesto do pacote afetado, ver um resumo da descoberta e resolver a anotação na seção Visão geral.

Para descartar alertas de solicitação pull, você deve navegar até a exibição de detalhes do alerta para fechar o alerta e resolver a anotação. Caso contrário, simplesmente alterar o status do comentário (1) resolve a anotação, mas não fecha nem corrige o alerta subjacente.

Para ver todo o conjunto de resultados para a sua branch de pull request, navegue até Repos>Advanced Security e selecione a sua branch de pull request. Selecionar Mostrar mais detalhes (2) na anotação direciona você para a exibição de detalhes do alerta na guia Segurança Avançada.

Artigos relacionados

• Saiba mais sobre os ecossistemas de pacotes suportados
• Solucionar problemas de verificação de dependência
• Configurar a análise de segredos
• Saiba mais sobre Segurança Avançada