Verificação de código do CodeQL para linguagens compiladas

Comparar modos de construção

Escolher um modo de build

Quando você estiver configurando code scanning pela primeira vez ou em vários repositórios, é melhor usar a configuração padrão. A configuração padrão usa o método mais simples disponível para gerar um CodeQL banco de dados e analisar seu código, para que você possa começar a corrigir alertas assim que possível. Depois de resolver os alertas iniciais, convém alternar para a configuração avançada com um processo de compilação manual para repositórios de alto risco.

Para obter comportamentos específicos autobuild do idioma, requisitos do executor e detalhes do modo de build para idiomas compilados, consulte Opções e etapas de build do CodeQL para idiomas compilados.

Usar vários modos de build em um repositório de vários idiomas

Para repositórios com várias linguagens compiladas, você pode usar diferentes modos de compilação para diferentes idiomas. Por exemplo, se o repositório contiver C/C++, C# e Java, convém fornecer etapas de build manuais para um idioma (aqui C/C++). Este fluxo de trabalho especifica um modo de compilação diferente para cada idioma.

strategy:
  matrix:
    include:
      # Analyzes C and C++ code using the commands in `Build C and C++ code`
      - language: c-cpp
        build-mode: manual
      # Analyzes C# code by automatically detecting a build
      - language: csharp
        build-mode: autobuild
      # Analyzes Java code directly from the codebase without a build
      - language: java-kotlin
        build-mode: none # analyzes Java only
steps:
- name: Checkout repository
  uses: actions/checkout@v5

# Initializes CodeQL tools and creates a codebase for analysis.
- name: Initialize CodeQL
  uses: github/codeql-action/init@v4
  with:
    languages: ${{ matrix.language }}
- if: ${{ matrix.build-mode == 'manual' }}
  name: Build C and C++ code
  run: |
    echo 'If you are using a "manual" build mode for one or more of the' \
      'languages you are analyzing, replace this with the commands to build' \
      'your code, for example:'
    echo ' make bootstrap'
    echo ' make release'
    exit 1

Para obter informações sobre os idiomas, bibliotecas e estruturas com suporte na versão mais recente, CodeQLconsulte linguagens e estruturas com suporte na CodeQL documentação. Para obter informações sobre os requisitos do sistema para executar a versão mais recente, CodeQLconsulte os requisitos do CodeQL sistema na documentação.

Habilitar o cache de dependência para CodeQL

Para fluxos de trabalho de configuração padrão, o cache de dependência é habilitado apenas para GitHubexecutores hospedados em repositórios públicos e privados.

Para fluxos de trabalho de configuração avançada, o cache de dependências está desativado por padrão. Para habilitar o cache de dependência CodeQL, utilize a configuração dependency-caching para a ação CodeQL em seu fluxo de trabalho de configuração avançada. Esta configuração aceita os seguintes valores:

•         `false`
          /
          `none`
          /
          `off`: o cache de dependências está desativado (padrão).
  

•         `restore`: restaure apenas os caches existentes, não armazene novos caches.
  

•         `store`: armazene apenas novos caches, não restaure caches existentes.
  

•         `true`
          /
          `full`
          /
          `on`: restaurar caches existentes e armazenar novos caches.
  

Por exemplo, as seguintes configurações habilitariam o cache de dependência para a ação CodeQL :

    # Initializes CodeQL with dependency caching enabled
    - name: Initialize CodeQL
      uses: github/codeql-action/init@v4
      with:
        languages: java
        dependency-caching: true

Usar o none modo de compilação para CodeQL

Para C/C++, C#, Java e Rust, CodeQL cria um banco de dados sem exigir um build ao habilitar a configuração padrão para code scanning a menos que o repositório também inclua código Kotlin. Se um repositório contiver código Kotlin além de código Java, a configuração padrão é habilitada com o processo de construção automática porque a análise de Kotlin exigirá uma construção.

A criação de um CodeQL banco de dados sem um build poderá produzir resultados menos precisos do que usar autobuild ou etapas manuais de build se:

• Os scripts de compilação não podem ser consultados para obter informações de dependência, e as suposições de dependência são imprecisas.
• O repositório normalmente gera código durante o processo de compilação.

Para usar o autobuild ou etapas de compilação manuais, é possível usar a configuração avançada.

Usar autobuild para CodeQL

A ação CodeQL usa o autobuild para analisar linguagens compiladas nos seguintes casos.

• A configuração padrão está habilitada e o idioma não suporta a compilação none (com suporte para C/C++, C#, Java e Rust).
• A configuração avançada está habilitada e o fluxo de trabalho especifica build-mode: autobuild.
• A configuração avançada está habilitada e o fluxo de trabalho tem uma etapa de compilação automática para o idioma usando a ação autobuild (github/codeql-action/autobuild@v4).

Use a opção build-mode

# Initializes the CodeQL tools for scanning.
name: Analyze
strategy:
  matrix:
    include:
      # Analyze C and C++ code
      - language: c-cpp
        build-mode: autobuild
      # Analyze Go code
      - language: go
        build-mode: autobuild

steps:
  - uses: github/codeql-action/init@v4
    with:
      languages: ${{ matrix.language }}
      build-mode: ${{ matrix.build-mode }}

Usar a etapa do "Autobuild"

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
      uses: github/codeql-action/init@v4
      with:
        languages: ${{ matrix.language }}

    - name: Autobuild
      uses: github/codeql-action/autobuild@v4

Especificar as etapas de compilação manualmente

Você só pode especificar etapas de compilação manual se tiver ativado a configuração avançada. Consulte [link para a documentação]. Como definir a configuração avançada para verificação de código.

Se autobuild falhar ou se você quiser analisar um conjunto diferente de arquivos de origem daqueles criados pelo processo autobuild, será necessário fazer o seguinte:

• Se o fluxo de trabalho especificar um modo de compilação para a linguagem, altere o modo de compilação para manual.
• Se o fluxo de trabalho contiver uma etapa de autobuild, remova ou comente a etapa de autobuild no fluxo de trabalho.

Em seguida, descompacte a etapa run e especifique manualmente o processo de build a ser usado. Para C/C++, C#, Go, Java, Kotlin e Swift, CodeQL analisará todo o código-fonte gerado pelas etapas de compilação especificadas.

Atualize o fluxo de trabalho para definir build-mode como manual.

# Initializes the CodeQL tools for scanning.
- name: Initialize CodeQL
- uses: github/codeql-action/init@v4
  with:
    languages: ${{ matrix.language }}
    build-mode: manual
- uses: github/codeql-action/analyze@v4
  with:
    category: "/language:${{ matrix.language }}"

Como alternativa, atualize seu fluxo de trabalho para comentar a etapa “compilação automática”.

    # Autobuild attempts to build any compiled languages.
    # - name: Autobuild
    #  uses: github/codeql-action/autobuild@v4

Adicionar comandos de build

Quando a compilação manual estiver ativada, remova o comentário da etapa run no fluxo de trabalho e adicione comandos de compilação adequados ao seu repositório. A etapa run executa programas de linha de comando usando o shell do sistema operacional. Você pode modificar esses comandos e adicionar mais comandos para personalizar o processo de compilação.

- run: |
    make bootstrap
    make release

Para obter mais informações sobre a palavra-chave run, confira Sintaxe de fluxo de trabalho para o GitHub Actions.

Se você adicionou etapas manuais no processo de build para linguagens compiladas e code scanning ainda não está funcionando no repositório, entre em contato conosco por meio do Portal de suporte do GitHub.