# Suporte SARIF para a varredura de código Verifique se os arquivos SARIF de ferramentas de terceiros atendem aos padrões de GitHub. GitHub pode analisar arquivos SARIF produzidos por ferramentas de terceiros para exibir code scanning alertas em repositórios. Para obter mais informações, consulte [Sobre arquivos SARIF para verificação de código](/pt/enterprise-server@3.19/code-security/concepts/code-scanning/sarif-files). Este artigo destaca as principais propriedades dos arquivos SARIF para ajudá-lo a carregar arquivos SARIF que atendem aos GitHubrequisitos e podem ser convertidos em alertas úteis. Se você estiver usando GitHub Actions com o Fluxo de trabalho de análise do CodeQL ou usando o CodeQL CLI, então os resultados de code scanning usarão automaticamente o subconjunto compatível do SARIF 2.1.0. ## Dados para evitar alertas duplicados Cada vez que os resultados de uma nova verificação de código são carregados, os resultados são processados e os alertas são adicionados ao repositório. Para evitar alertas duplicados para o mesmo problema, code scanning usa assinaturas para associar os resultados entre várias execuções, de modo que os alertas apareçam apenas uma vez na execução mais recente da ramificação selecionada. Isto torna possível combinar alertas com a linha de código correta quando os arquivos são editados. O `ruleId` de um resultado deve ser o mesmo em toda a análise. ### Caminhos de arquivo consistentes O caminho do arquivo precisa ser consistente entre as execuções para habilitar a computação de uma impressão digital estável. Se os caminhos de arquivo forem diferentes para o mesmo resultado, sempre que houver uma nova análise, um novo alerta será criado e o antigo será fechado. Isso causará vários alertas para o mesmo resultado. ### Geração de impressão digital GitHub usa a `partialFingerprints` propriedade no padrão OASIS para detectar quando dois resultados são logicamente idênticos. Para obter mais informações, consulte a entrada [propriedade partialFingerprints](https://docs.oasis-open.org/sarif/sarif/v2.1.0/cs01/sarif-v2.1.0-cs01.html#_Toc16012611) na documentação do OASIS. Arquivos SARIF criados pelo Fluxo de trabalho de análise do CodeQL ou usando o CodeQL CLI incluem dados de impressão digital. Se você carregar um arquivo SARIF usando a ação `upload-sarif` e esses dados estiverem ausentes, GitHub tentará preencher o `partialFingerprints` campo dos arquivos de origem. Para saber mais sobre como carregar resultados, consulte [Fazer o upload de arquivo SARIF para o GitHub](/pt/enterprise-server@3.19/code-security/code-scanning/integrating-with-code-scanning/uploading-a-sarif-file-to-github). Se você carregar um arquivo SARIF sem dados de identificadores exclusivos usando o endpoint da API `/code-scanning/sarifs`, os alertas code scanning serão processados e exibidos, mas os usuários poderão ver alertas duplicados. Para evitar ver alertas duplicados, calcule dados de impressão digital e preencha a propriedade `partialFingerprints` antes de carregar o arquivo SARIF. Você pode achar o script usado pela ação `upload-sarif` um ponto de partida útil: . Para obter mais informações sobre a API, consulte [Pontos de extremidade da API REST para varredura de código](/pt/enterprise-server@3.19/rest/code-scanning/code-scanning#upload-an-analysis-as-sarif-data). ## Regras e resultados Os arquivos SARIF dão suporte a regras e resultados. As informações armazenadas nesses elementos são semelhantes, mas têm propósitos diferentes. * As regras são uma matriz de objetos `reportingDescriptor` que estão incluídos no objeto `toolComponent`. Nele, são armazenados detalhes das regras que são executadas durante a análise. As informações nesses objetos devem ser alteradas com pouca frequência, geralmente quando você atualiza a ferramenta. * Os resultados são armazenados como uma série de objetos `result` sob `results` no objeto `run`. Cada objeto `result` contém detalhes de um alerta na base de código. Dentro do objeto `results`, você pode fazer referência à regra que detectou o alerta. Ao comparar arquivos SARIF gerados pela análise de diferentes bases de código com a mesma ferramenta e regras, verá diferenças nos resultados das análises, mas não nas regras. ## Locais do arquivo de origem A especificação dos locais do arquivo de origem e linhas de código garante que os alertas de verificação de código sejam exibidos corretamente no arquivo que contém o problema identificado, permitindo a resolução do problema direcionado. Essa precisão aumenta a eficiência dos processos de revisão e resolução de código, simplificando os fluxos de trabalho de desenvolvimento, permitindo que os desenvolvedores resolvam problemas diretamente no contexto de sua base de código. Code scanning também exibirá alertas nos resultados das verificações do pull request quando todas as linhas de código identificadas pelo alerta estiverem no diff do pull request. Para exibição em uma verificação de pull request, um alerta deve atender a todas as seguintes condições: * Todas as linhas de código identificadas pelo alerta existem na comparação da pull request, incluindo a primeira linha do alerta. * O alerta deve existir nas linhas de código adicionadas ou editadas na pull request, e não nas linhas que foram excluídas. O objeto `physicalLocation` em um arquivo SARIF enviado identifica as linhas de código de um alerta. Para obter mais informações, consulte [`physicalLocation` objeto](#physicallocation-object). ### Local raiz para arquivos de origem Code scanning interpreta os resultados reportados com caminhos relativos como relativos à raiz do repositório analisado. Se um resultado contiver um URI absoluto, ele será convertido em um URI relativo. Em seguida, o URI relativo pode ser correspondido com um arquivo confirmado no repositório. Você pode fornecer a raiz de origem para conversão de URIs absolutos em relativos de uma das maneiras a seguir. * [ `checkout_path` ](https://github.com/github/codeql-action/blob/c2c0a2908e95769d01b907f9930050ecb5cf050d/analyze/action.yml#L44-L47) entrada para a `github/codeql-action/analyze` ação * `checkout_uri` parâmetro para o ponto de extremidade da API de upload de SARIF. Para obter mais informações, consulte [Pontos de extremidade da API REST para varredura de código](/pt/enterprise-server@3.19/rest/code-scanning/code-scanning#upload-an-analysis-as-sarif-data). * [ `invocations[0].workingDirectory.uri` ](https://docs.oasis-open.org/sarif/sarif/v2.1.0/csprd01/sarif-v2.1.0-csprd01.html#_Toc9244365) propriedade no objeto `run` no arquivo SARIF Se você fornecer uma raiz de origem, qualquer local de um artefato especificado usando um URI absoluto deverá usar o mesmo esquema de URI. Se houver uma incompatibilidade entre o esquema de URI para a raiz de origem e um ou mais URIs absolutos, o upload será rejeitado. Por exemplo, um arquivo SARIF é carregado usando uma raiz de origem de `file:///github/workspace`. ```shell # Conversion of absolute URIs to relative URIs for location artifacts file:///github/workspace/src/main.go -> src/main.go file:///tmp/go-build/tmp.go -> file:///tmp/go-build/tmp.go ``` O arquivo é carregado com êxito, pois ambos os URIs absolutos usam o mesmo esquema de URI que a raiz de origem. ### Resolução do Symlink Se o URI relativo de um resultado for comparado a um arquivo definido usando um link simbólico, a varredura de código não poderá exibir o resultado. Portanto, você precisa resolver todos os arquivos com links simbólicos e relatar quaisquer resultados nesses arquivos usando o URI resolvido. ## Compatibilidade de arquivos Você pode verificar se um arquivo SARIF é compatível com code scanning testando-o em relação às regras de ingestão de GitHub. Para obter mais informações, acesse o [validador de SARIF da Microsoft](https://sarifweb.azurewebsites.net/). Para cada arquivo SARIF compactado com gzip, o upload do SARIF dá suporte a um tamanho máximo de 10 MB. Todos os uploads acima desse limite são rejeitados. Se o arquivo SARIF for muito grande porque contém muitos resultados, você deverá atualizar a configuração para se concentrar nos resultados das regras ou consultas mais importantes. Para obter mais informações, consulte [O arquivo de resultados SARIF é muito grande](/pt/enterprise-server@3.19/code-security/how-tos/scan-code-for-vulnerabilities/troubleshooting/troubleshooting-sarif-uploads/file-too-large). Code scanning dá suporte ao carregamento de um número máximo de entradas para os objetos de dados na tabela a seguir. Se um desses objetos exceder o valor máximo, o arquivo SARIF será rejeitado. Para alguns objetos, há também um limite adicional no número de valores que serão exibidos. Sempre que possível, os valores mais importantes são mostrados. Para aproveitar ao máximo sua análise quando ela incluir dados acima dos limites suportados, tente otimizar a configuração da análise (por exemplo, para a ferramenta CodeQL, identifique e desabilite as consultas com mais ruído). Para obter mais informações, consulte [Os resultados do SARIF excedem um ou mais limites](/pt/enterprise-server@3.19/code-security/how-tos/scan-code-for-vulnerabilities/troubleshooting/troubleshooting-sarif-uploads/results-exceed-limit).
| **Dados SARIF** | **Valores máximos** | **Limites de truncamento de dados** | | ---------------------------------------- | :-----------------: | ------------------------------------------------------------------------------------------- | | Execuções por arquivo | 20 | Nenhum | | Resultados por execução | 25,000 | Somente os 5 mil resultados principais serão incluídos, priorizados por severidade. | | Regras por execução | 25,000 | Nenhum | | Extensões de ferramenta por execução | 100 | Nenhum | | Locais de fluxo de threads por resultado | 10.000 | Somente os mil principais locais de fluxo de threads serão incluídos, usando a priorização. | | Local por resultado | 1,000 | Somente 100 locais serão incluídos. | | Marcas por regra | 20 | Somente dez marcas serão incluídas. | | Limite de alerta | 1.000.000 | Nenhum |
Para obter informações sobre outros erros, consulte [Solução de problemas de uploads SARIF](/pt/enterprise-server@3.19/code-security/how-tos/scan-code-for-vulnerabilities/troubleshooting/troubleshooting-sarif-uploads). ## Propriedades suportadas Se você usar um mecanismo de análise de código diferente de CodeQL, poderá revisar as propriedades SARIF com suporte para otimizar a forma como os resultados da sua análise aparecerão em GitHub. > \[!NOTE] > Você deve fornecer um valor explícito para qualquer propriedade marcada como "obrigatória". Não há suporte para cadeias de caracteres vazias em propriedades obrigatórias. Qualquer arquivo de saída SARIF 2.1.0 válido pode ser carregado, no entanto, code scanning usará apenas as seguintes propriedades com suporte. ### objeto `sarifLog` | Nome | Obrigatório | Description | | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `$schema` | | O URI do esquema SARIF JSON para a versão 2.1.0. Por exemplo, `https://json.schemastore.org/sarif-2.1.0.json`. | | `version` | | | | Code scanning só dá suporte à versão `2.1.0`SARIF. | | | | `runs[]` | | Um arquivo SARIF contém uma matriz de uma ou mais execuções. Cada execução representa uma execução única de uma ferramenta de análise. Para obter mais informações sobre `run`, consulte o [`run` objeto](#run-object). | ### objeto `run` Code scanning usa o `run` objeto para filtrar resultados por ferramenta e fornecer informações sobre a origem de um resultado. O objeto `run` contém o objeto `tool.driver` de componentes da ferramenta, que contém informações sobre a ferramenta que gerou os resultados. Cada `run` pode ter resultados apenas para uma ferramenta de análise. | Nome | Obrigatório | Description | | ------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `tool.driver` | | Um objeto `toolComponent` que descreve a ferramenta de análise. Para obter mais informações, consulte [`toolComponent` do objeto](#toolcomponent-object). | | `tool.extensions[]` | | Uma matriz de objetos `toolComponent` que representam plug-ins ou extensões usadas pela ferramenta durante a análise. Para obter mais informações, consulte [`toolComponent` do objeto](#toolcomponent-object). | | `invocation.workingDirectory.uri` | | Esse campo é usado somente quando `checkout_uri` (somente a API de upload sarif) ou `checkout_path` (GitHub Actions somente) não são fornecidos. O valor é usado para converter URIs absolutos usados em [`physicalLocation` objetos](#physicallocation-object) em URIs relativos. Para obter mais informações, consulte [Como especificar a raiz para arquivos de origem](#root-location-for-source-files). | | `results[]` | | Os resultados da ferramenta de análise. | | Code scanning exibe os resultados em GitHub. Para obter mais informações, consulte [`result` do objeto](#result-object). | | | ### objeto `toolComponent` | Nome | Obrigatório | Description | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `name` | | O nome da ferramenta de análise. | | Code scanning exibe o nome GitHub para permitir que você filtre os resultados por ferramenta. | | | | `version` | | A versão da ferramenta de análise. | | Code scanning usa o número de versão para acompanhar quando os resultados podem ter sido alterados devido a uma alteração de versão da ferramenta em vez de uma alteração no código que está sendo analisado. Se o arquivo SARIF incluir o `semanticVersion` campo, `version` não será usado por code scanning. | | | | `semanticVersion` | | A versão da ferramenta de análise, especificada pelo formato Versionamento Semântico 2.0. | | Code scanning usa o número de versão para acompanhar quando os resultados podem ter sido alterados devido a uma alteração de versão da ferramenta em vez de uma alteração no código que está sendo analisado. Se o arquivo SARIF incluir o `semanticVersion` campo, `version` não será usado por code scanning. Para obter mais informações, consulte [Versionamento Semântico 2.0.0](https://semver.org/) na documentação do Versionamento Semântico. | | | | `rules[]` | | A matriz de objetos `reportingDescriptor` que representa as regras. A ferramenta de análise usa regras para encontrar problemas no código que está sendo analisado. Para obter mais informações, consulte [`reportingDescriptor` do objeto](#reportingdescriptor-object). | ### objeto `reportingDescriptor` Nele, são armazenados detalhes das regras que são executadas durante a análise. As informações nesses objetos devem ser alteradas com pouca frequência, geralmente quando você atualiza a ferramenta. Para obter mais informações, consulte [Regras e resultados](#rules-and-results) acima. | Nome | Obrigatório | Description | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `id` | | Um identificador exclusivo para a regra. O `id` é referenciado por outras partes do arquivo SARIF e pode ser usado por code scanning para exibir URLs em GitHub. | | `name` | | O nome da regra. | | Code scanning exibe o nome para permitir que os resultados sejam filtrados por regra em GitHub. Limitado a 255 caracteres. | | | | `shortDescription.text` | | Uma descrição concisa da regra. | | Code scanning exibe a breve descrição ao GitHub lado dos resultados associados. Limitado a 1024 caracteres. | | | | `fullDescription.text` | | Descrição da regra. | | Code scanning exibe a descrição completa ao GitHub lado dos resultados associados. Limitado a 1024 caracteres. | | | | `defaultConfiguration.level` | | Nível de gravidade padrão da regra. | | Code scanning usa níveis de severidade para ajudá-lo a entender o quão crítico é o resultado para uma determinada regra. Por padrão, o `defaultConfiguration.level` está definido como `warning`. No entanto, você pode substituir o nível padrão de uma regra definindo o atributo `level` no objeto `result` associado ao resultado. Para obter mais informações, consulte a documentação no [`result` do objeto](#result-object). Os valores válidos para `defaultConfiguration.level` são: `note`, `warning` e `error`. | | | | `help.text` | | Documentação da regra usando o formato de texto. | | Code scanning exibe esta documentação de ajuda ao lado dos resultados associados. | | | | `help.markdown` | | (Recomendado) Documentação da regra usando o formato Markdown. | | Code scanning exibe esta documentação de ajuda ao lado dos resultados associados. Quando `help.markdown` está disponível, ele é exibido em vez de `help.text`. | | | | `properties.tags[]` | | Uma matriz de cadeias de caracteres. | | Code scanning usa `tags` para permitir que você filtre os resultados em GitHub. Por exemplo, é possível filtrar todos os resultados que têm a marca `security`. | | | | `properties.precision` | | (Recomendado) Uma cadeia de caracteres que indica a frequência com que os resultados indicados por essa regra são verdadeiros. Por exemplo, se uma regra tem uma alta taxa conhecida de falsos-positivos, a precisão deve ser `low`. | | Code scanning ordena os resultados por precisão com base em GitHub, de modo que os resultados com maior `level` e maior `precision` sejam mostrados primeiro. Pode ser `very-high`, `high`, `medium` ou `low`. | | | | `properties.problem.severity` | | (Recomendado) Uma cadeia de caracteres que indica o nível de gravidade de todos os alertas gerados por uma consulta que não é de segurança. Isso, juntamente com a propriedade `properties.precision`, determina se os resultados são exibidos por padrão em GitHub, de modo que os resultados com o maior `problem.severity` e o maior `precision` sejam mostrados primeiro. Pode ser `error`, `warning` ou `recommendation`. | | `properties.security-severity` | | (Recomendado apenas para regras de segurança) Se você incluir um valor para esse campo, os resultados da regra serão tratados como resultados de segurança. Uma sequência representando uma pontuação que indica o nível de gravidade, um valor entre 0 e 10 para as consultas de segurança (`@tags` inclui `security`). Isto, juntamente com a propriedade `properties.precision`, determina se os resultados são exibidos por padrão em GitHub, para que os resultados com o maior `security-severity` e o maior `precision` sejam mostrados primeiro. | | Code scanning converte pontuações numéricas da seguinte maneira: mais de 9,0 é `critical`, de 7,0 para 8,9 é `high`, de 4,0 a 6,9 é `medium` e de 0,1 a 3,9 é `low`. Um valor de 0 ou qualquer outro valor fora do intervalo determinado é considerado como sem gravidade de segurança. | | | ### objeto `result` Cada objeto `result` contém detalhes de um alerta na base de código. Dentro do objeto `results`, você pode fazer referência à regra que detectou o alerta. Para obter mais informações, consulte [Regras e resultados](#rules-and-results) acima. | Nome | Obrigatório | Description | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `ruleId` | | O identificador exclusivo da regra (`reportingDescriptor.id`). Para obter mais informações, consulte [`reportingDescriptor` do objeto](#reportingdescriptor-object). | | Code scanning usa o identificador de regra para filtrar os resultados por regra em GitHub. | | | | `ruleIndex` | | O índice da regra associada (objeto`reportingDescriptor` ) na matriz `rules` de componentes da ferramenta. Para obter mais informações, consulte [`run` do objeto](#run-object). O intervalo permitido para essa propriedade 0 a 2^63 - 1. | | `rule` | | Uma referência usada para localizar a regra (descritor de relatório) para esse resultado. Para obter mais informações, consulte [`reportingDescriptor` do objeto](#reportingdescriptor-object). | | `level` | | A gravidade do resultado. Esse nível sobrepõe a severidade-padrão definida pela regra. | | Code scanning usa o nível para filtrar os resultados por severidade em GitHub. | | | | `message.text` | | Uma mensagem que descreve o resultado. | | Code scanning exibe o texto da mensagem como o título do resultado. Apenas a primeira frase da mensagem será exibida quando o espaço visível for limitado. | | | | `locations[]` | | O conjunto de locais em que o resultado foi detectado até, no máximo, dez. Só um local deve ser incluído, a não ser que o problema só possa ser corrigido fazendo uma alteração em cada local especificado. | | **Nota:** Pelo menos um local é necessário para code scanning exibir um resultado. | | | | Code scanning usará essa propriedade para decidir qual arquivo anotar com o resultado. Apenas o primeiro valor desse array é usado. Todos os outros valores são ignorados. | | | | `partialFingerprints` | | Um conjunto de cadeias de caracteres usadas para acompanhar a identidade exclusiva do resultado. | | Code scanning usa `partialFingerprints` para identificar com precisão quais resultados são os mesmos entre commits e branches. | | | | Code scanning tentará usar `partialFingerprints` se existirem. Se você estiver carregando arquivos SARIF de terceiros com a `upload-action`, a ação criará `partialFingerprints` para você quando eles não estiverem incluídos no arquivo SARIF. Para obter mais informações, consulte [Como fornecer dados para rastrear alertas de exame de código nas execuções](#data-for-preventing-duplicated-alerts). | | | | \*\*Nota:\*\*Code scanning só usa o `primaryLocationLineHash`. | | | | `codeFlows[].threadFlows[].locations[]` | | Uma matriz de objetos `location` para um objeto `threadFlow`, que descreve o progresso de um programa por meio de um thread de execução. Um objeto `codeFlow` descreve um padrão de execução de código usado para detectar um resultado. Se forem fornecidos fluxos de código, code scanning expandirá os fluxos de código em GitHub para o resultado relevante. Para obter mais informações, consulte [`location` do objeto](#location-object). | | `relatedLocations[]` | | Um conjunto de locais relevantes para este resultado. | | Code scanning vinculará a locais relacionados quando eles forem inseridos na mensagem de resultado. Para obter mais informações, consulte [`location` do objeto](#location-object). | | | ### objeto `location` Um local dentro de um artefato de programação, como, por exemplo, um arquivo no repositório ou um arquivo gerado durante uma criação. | Nome | Obrigatório | Description | | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `location.id` | | Um identificador exclusivo que distingue esse local de todos os outros locais em um só objeto de resultado. O intervalo permitido para essa propriedade 0 a 2^63 - 1. | | `location.physicalLocation` | | Identifica o artefato e a região. Para obter mais informações, consulte [`physicalLocation`](#physicallocation-object). | | `location.message.text` | | Uma mensagem relevante à localização. | ### objeto `physicalLocation` | Nome | Obrigatório | Description | | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `artifactLocation.uri` | | Um URI que indica o local de um artefato, geralmente um arquivo no repositório ou gerado durante um build. Para obter os melhores resultados, recomendamos que este seja um caminho relativo a partir da raiz do repositório do GitHub que está sendo analisado. Por exemplo, `src/main.js`. Para obter mais informações sobre URIs de artefato, consulte [Como especificar a raiz para arquivos de origem](#root-location-for-source-files). | | `region.startLine` | | O número de linha do primeiro caractere na região. | | `region.startColumn` | | O número da coluna do primeiro caractere na região. | | `region.endLine` | | O número de linha do último caractere na região. | | `region.endColumn` | | O número da coluna do caractere após o final da região. | ### objeto `runAutomationDetails` O objeto `runAutomationDetails` contém informações que especificam a identidade de uma execução. | Nome | Obrigatório | Description | | ---- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `id` | | Uma cadeia de caracteres que identifica a categoria da análise e a ID de execução. Use se você quiser fazer upload de vários arquivos SARIF para a mesma ferramenta e commit, mas executado em diferentes idiomas ou diferentes partes do código. | O uso do objeto `runAutomationDetails` é opcional. O campo `id` pode incluir uma categoria de análise e uma ID de execução. Não usamos a parte da ID de execução do campo `id`, mas a armazenamos. Use a categoria para distinguir entre múltiplas análises para a mesma ferramenta ou commit, mas executada em diferentes linguagens ou partes diferentes do código. Use o ID de execução para identificar a execução específica da análise, como a data em que a análise foi executada. `id` é interpretado como `category/run-id`. Se a `id` não contiver nenhuma barra (`/`), a cadeia de caracteres inteira será a `run_id` e a `category` ficará vazia. Caso contrário, a `category` será tudo na cadeia de caracteres até a última barra, e a `run_id` será tudo após ela. | `id` | categoria | `run_id` | | ---------------------------- | ----------------- | ------------------------ | | my-analysis/tool1/2022-01-02 | my-analysis/tool1 | 02-01-2022 | | my-analysis/tool1/ | my-analysis/tool1 | Nenhum | | minha-análise para tool1 | Nenhum | minha-análise para tool1 | * A execução com uma `id` igual a "my-analysis/tool1/2021-02-01" pertence à categoria "my-analysis/tool1". * A execução com uma `id` igual a "my-analysis/tool1/" pertence à categoria "my-analysis/tool1", mas não é distinta das outras execuções nessa categoria. * A execução cuja `id` é "my-analysis for tool1" tem um identificador único, mas não pode ser inferida como pertencente a nenhuma categoria. Para obter mais informações sobre o objeto `runAutomationDetails` e o campo `id`, confira o [objeto runAutomationDetails](https://docs.oasis-open.org/sarif/sarif/v2.1.0/cs01/sarif-v2.1.0-cs01.html#_Toc16012479) na documentação do OASIS. Observe que o resto dos campos compatíveis são ignorados. ## Exemplos de arquivos de saída SARIF Estes exemplos de arquivos de saída SARIF mostram as propriedades compatíveis e os valores de exemplo. ### Exemplo com as propriedades mínimas necessárias Este arquivo de saída SARIF contém valores de exemplo para mostrar as propriedades mínimas necessárias para que os resultados code scanning funcionem conforme o esperado. Se você remover quaisquer propriedades, omitir valores ou usar uma cadeia de caracteres vazia, esses dados não serão exibidos corretamente ou sincronizados GitHub. ```json { "$schema": "https://json.schemastore.org/sarif-2.1.0.json", "version": "2.1.0", "runs": [ { "tool": { "driver": { "name": "Tool Name", "rules": [ { "id": "R01" ... "properties" : { "id" : "java/unsafe-deserialization", "kind" : "path-problem", "name" : "...", "problem.severity" : "error", "security-severity" : "9.8", } } ] } }, "results": [ { "ruleId": "R01", "message": { "text": "Result text. This result does not have a rule associated." }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "fileURI" }, "region": { "startLine": 2, "startColumn": 7, "endColumn": 10 } } } ], "partialFingerprints": { "primaryLocationLineHash": "39fa2ee980eb94b0:1" } } ] } ] } ``` ### Orientações relativas ao URI para produtores de SARIF Este arquivo de saída SARIF contém exemplos de valores para o campo `originalUriBaseIds`, mostrando as propriedades mínimas que um produtor SARIF deve incluir ao usar referências URI relativas. > \[!NOTE] > Embora essa propriedade não seja exigida por GitHub para que os resultados de code scanning sejam exibidos corretamente, ela é exigida para produzir uma saída válida no formato SARIF ao usar referências URI relativas. ```json { "$schema": "https://json.schemastore.org/sarif-2.1.0.json", "version": "2.1.0", "runs": [ { "tool": { "driver": { "name": "Tool Name", "rules": [ { "id": "R01" ... "properties" : { "id" : "java/unsafe-deserialization", "kind" : "path-problem", "name" : "...", "problem.severity" : "error", "security-severity" : "9.8", } } ] } }, "originalUriBaseIds": { "PROJECTROOT": { "uri": "file:///C:/Users/Mary/code/TheProject/", "description": { "text": "The root directory for all project files." } }, "%SRCROOT%": { "uri": "src/", "uriBaseId": "PROJECTROOT", "description": { "text": "The root of the source tree." } } }, "results": [ { "ruleId": "R01", "message": { "text": "Result text. This result does not have a rule associated." }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "fileURI", "uriBaseId": "%SRCROOT%" }, "region": { "startLine": 2, "startColumn": 7, "endColumn": 10 } } } ], "partialFingerprints": { "primaryLocationLineHash": "39fa2ee980eb94b0:1" } } ] } ] } ``` ### Exemplo que mostra todas as propriedades compatíveis como SARIF Este arquivo de saída SARIF tem valores de exemplo para mostrar todas as propriedades SARIF com suporte para code scanning. ```json { "$schema": "https://json.schemastore.org/sarif-2.1.0.json", "version": "2.1.0", "runs": [ { "tool": { "driver": { "name": "Tool Name", "semanticVersion": "2.0.0", "rules": [ { "id": "3f292041e51d22005ce48f39df3585d44ce1b0ad", "name": "js/unused-local-variable", "shortDescription": { "text": "Unused variable, import, function or class" }, "fullDescription": { "text": "Unused variables, imports, functions or classes may be a symptom of a bug and should be examined carefully." }, "defaultConfiguration": { "level": "note" }, "properties": { "tags": [ "maintainability" ], "precision": "very-high" } }, { "id": "d5b664aefd5ca4b21b52fdc1d744d7d6ab6886d0", "name": "js/inconsistent-use-of-new", "shortDescription": { "text": "Inconsistent use of 'new'" }, "fullDescription": { "text": "If a function is intended to be a constructor, it should always be invoked with 'new'. Otherwise, it should always be invoked as a normal function, that is, without 'new'." }, "properties": { "tags": [ "reliability", "correctness", "language-features" ], "precision": "very-high" } }, { "id": "R01" } ] } }, "automationDetails": { "id": "my-category/" }, "results": [ { "ruleId": "3f292041e51d22005ce48f39df3585d44ce1b0ad", "ruleIndex": 0, "message": { "text": "Unused variable foo." }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "main.js", "uriBaseId": "%SRCROOT%" }, "region": { "startLine": 2, "startColumn": 7, "endColumn": 10 } } } ], "partialFingerprints": { "primaryLocationLineHash": "39fa2ee980eb94b0:1", "primaryLocationStartColumnFingerprint": "4" } }, { "ruleId": "d5b664aefd5ca4b21b52fdc1d744d7d6ab6886d0", "ruleIndex": 1, "message": { "text": "Function resolvingPromise is sometimes invoked as a constructor (for example [here](1)), and sometimes as a normal function (for example [here](2))." }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "src/promises.js", "uriBaseId": "%SRCROOT%" }, "region": { "startLine": 2 } } } ], "partialFingerprints": { "primaryLocationLineHash": "5061c3315a741b7d:1", "primaryLocationStartColumnFingerprint": "7" }, "relatedLocations": [ { "id": 1, "physicalLocation": { "artifactLocation": { "uri": "src/ParseObject.js", "uriBaseId": "%SRCROOT%" }, "region": { "startLine": 2281, "startColumn": 33, "endColumn": 55 } }, "message": { "text": "here" } }, { "id": 2, "physicalLocation": { "artifactLocation": { "uri": "src/LiveQueryClient.js", "uriBaseId": "%SRCROOT%" }, "region": { "startLine": 166 } }, "message": { "text": "here" } } ] }, { "ruleId": "R01", "message": { "text": "Specifying both [ruleIndex](1) and [ruleId](2) might lead to inconsistencies." }, "level": "error", "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "full.sarif", "uriBaseId": "%SRCROOT%" }, "region": { "startLine": 54, "startColumn": 10, "endLine": 55, "endColumn": 25 } } } ], "relatedLocations": [ { "id": 1, "physicalLocation": { "artifactLocation": { "uri": "full.sarif" }, "region": { "startLine": 81, "startColumn": 10, "endColumn": 18 } }, "message": { "text": "here" } }, { "id": 2, "physicalLocation": { "artifactLocation": { "uri": "full.sarif" }, "region": { "startLine": 82, "startColumn": 10, "endColumn": 21 } }, "message": { "text": "here" } } ], "codeFlows": [ { "threadFlows": [ { "locations": [ { "location": { "physicalLocation": { "region": { "startLine": 11, "endLine": 29, "startColumn": 10, "endColumn": 18 }, "artifactLocation": { "uriBaseId": "%SRCROOT%", "uri": "full.sarif" } }, "message": { "text": "Rule has index 0" } } }, { "location": { "physicalLocation": { "region": { "endColumn": 47, "startColumn": 12, "startLine": 12 }, "artifactLocation": { "uriBaseId": "%SRCROOT%", "uri": "full.sarif" } } } } ] } ] } ], "partialFingerprints": { "primaryLocationLineHash": "ABC:2" } } ], "columnKind": "utf16CodeUnits" } ] } ```