Soporte de SARIF para escaneo de código

Acerca del soporte de SARIF

SARIF (Static Analysis Results Interchange Format) es un estándar OASIS que define un formato de archivo de salida. El estándar SARIF se utiliza para optimizar la manera en el que las herramientas de análisis estático comparten sus resultados. Code scanning es compatible con un subconjunto del modelo SARIF 2.1.0 JSON.

Para cargar un archivo SARIF desde un motor de análisis estático de código desde un tercero, necesitaras asegurarte de que los archivos cargados utilicen la versión SARIF 2.1.0. GitHub analizará el archivo SARIF y mostrará las alertas utilizando los resultados en tu repositorio como parte de la experiencia del code scanning. Para más información, consulta Subir un archivo SARIF a GitHub. Para obtener más información sobre el esquema de JSON SARIF 2.1.0, consulte sarif-schema-2.1.0.json.

Si estás utilizando GitHub Actions con Flujo de trabajo de análisis de CodeQL o CodeQL CLI, los resultados de code scanning usarán automáticamente el subconjunto compatible de SARIF 2.1.0. Para más información, consulta Establecimiento de la configuración avanzada para el examen del código o Utilizar el análisis de código de CodeQL con tu sistema de IC existente.

GitHub utiliza propiedades en el archivo SARIF para mostrar alertas. Por ejemplo, shortDescription y fullDescription aparecen en la parte superior de una alerta de code scanning. location permite que GitHub muestre anotaciones en el archivo de código. Para más información, consulta Acerca de las alertas de análisis de código.

Si no está familiarizado con SARIF y quiere obtener más información, consulte el repositorio SARIF tutorials de Microsoft.

Proporcionar datos para realizar un seguimiento de las alertas de code scanning entre ejecuciones

Cada vez que se cargan los resultados de un nuevo examen de código, los resultados se procesan y se agregan alertas al repositorio. Para prevenir las alertas duplicadas para el mismo problema, code scanning utiliza huellas dactilares para empatara los resultados a través de diversas ejecuciones para que solo aparezcan una vez en la última ejecución para la rama seleccionada. Esto hace posible emparejar las alertas con la línea de código correcta cuando se editan los archivos. El ruleID para un resultado debe ser el mismo en todo el análisis.

Informes de rutas de archivo coherentes

La ruta de acceso de archivo debe ser coherente en las ejecuciones para habilitar un cálculo de una huella digital estable. Si las rutas de archivo difieren para el mismo resultado, cada vez que se crea un nuevo análisis, se creará una nueva alerta y se cerrará la antigua. Esto provocará que haya varias alertas para el mismo resultado.

Inclusión de datos para la generación de huellas digitales

GitHub usa la propiedad partialFingerprints del estándar OASIS para detectar si hay dos resultados idénticos desde el punto de vista lógico. Para obtener más información, consulte la entrada propiedad partialFingerprints en la documentación de OASIS.

Los archivos SARIF que crea Flujo de trabajo de análisis de CodeQL o los que utilizan la CodeQL CLI incluyen datos de huellas digitales. Si carga un archivo SARIF con la acción upload-sarif y faltan estos datos, GitHub intenta rellenar el campo partialFingerprints a partir de los archivos de origen. Para más información sobre cómo cargar los resultados, consulta Subir un archivo SARIF a GitHub.

Si carga un archivo SARIF sin datos de huella digital utilizando el punto de conexión de la API /code-scanning/sarifs, se procesarán y se mostrarán las alertas del code scanning, pero es posible que los usuarios vean alertas duplicadas. Para evitar ver alertas duplicadas, debe calcular los datos de huella digital y rellenar la propiedad partialFingerprints antes de cargar el archivo SARIF. Puede que el script que utiliza la acción upload-sarif le resulte un buen punto de partida: https://github.com/github/codeql-action/blob/main/src/fingerprints.ts. Para obtener más información sobre la API, consulta Puntos de conexión de la API de REST para el análisis de código.

Descripción de las reglas y los resultados

Los archivos SARIF admiten reglas y resultados. La información almacenada en estos elementos es similar, pero sirve para diferentes propósitos.

Las reglas son una matriz de objetos reportingDescriptor que se incluyen en el objeto toolComponent. Aquí es donde almacenas los detalles de las reglas que se ejecutan durante el análisis. La información de estos objetos debe cambiar con poca frecuencia, normalmente al actualizar la herramienta.
Los resultados se almacenan como una serie de objetos result en results en el objeto run. Cada objeto result contiene detalles de una alerta en el código base. Dentro del objeto results, puedes hacer referencia a la regla que ha detectado la alerta.

Al comparar los archivos SARIF generados mediante el análisis de diferentes bases de código con la misma herramienta y las mismas reglas, tendrías que ver diferencias en los resultados de los análisis, pero no en las reglas.

Especificación de la ubicación para los archivos de origen

Especificar ubicaciones de archivos de origen y líneas de código garantiza que las alertas de análisis de código se muestren con precisión dentro del archivo que contiene el problema identificado, lo que permite la resolución de problemas de destino.

Esta precisión mejora la eficacia de los procesos de revisión y resolución de código, lo que simplifica los flujos de trabajo de desarrollo al permitir a los desarrolladores abordar problemas directamente en el contexto de su código base.

Code scanning también mostrará alertas en los resultados de la comprobación de solicitudes de incorporación de cambios cuando todas las líneas de código identificadas por la alerta existan en la diferencia de solicitud de incorporación de cambios.

Para que se muestre en una comprobación de solicitud de incorporación de cambios, una alerta debe cumplir todas las condiciones siguientes:

Todas las líneas de código identificadas por la alerta existen en la diferencia de solicitud de incorporación de cambios, incluida la primera línea de la alerta.
La alerta debe existir en las líneas de código agregadas o editadas en la solicitud de incorporación de cambios, no en las líneas eliminadas.

El objeto physicalLocation de un archivo SARIF enviado identifica las líneas de código de una alerta. Para más información, consulta el objeto physicalLocation .

Especificación de la raíz para los archivos de origen

Code scanning interpreta los resultados que se notifican con rutas de acceso relativas en relación con la raíz del repositorio analizado. Si un resultado contiene un URI absoluto, el URI se convierte en un URI relativo. A continuación, el URI relativo se puede emparejar con un archivo confirmado en el repositorio.

Puedes proporcionar la raíz de origen para la conversión de URI absolutos a relativos de una de las siguientes maneras.

checkout_path entrada a la github/codeql-action/analyze acción
checkout_uri parámetro al punto de conexión de la API de carga de SARIF. Para más información, consulta Puntos de conexión de la API de REST para el análisis de código.
invocations[0].workingDirectory.uri propiedad en el objeto run del archivo SARIF

Si proporciona una raíz de origen, cualquier ubicación de un artefacto especificado mediante un URI absoluto debe usar el mismo esquema de URI. Si hay una discrepancia entre el esquema de URI para la raíz de origen y uno o varios de los URI absolutos, se rechaza la carga.

Por ejemplo, un archivo SARIF se carga mediante una raíz de origen de file:///github/workspace.

# 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

El archivo se carga correctamente, ya que ambos URI absolutos usan el mismo esquema de URI que la raíz de origen.

Resolución de vínculos simbólicos antes de generar resultados de SARIF

Si el identificador URI relativo de un resultado coincide con un archivo definido mediante un vínculo simbólico, el examen de código no puede mostrar el resultado. Por lo tanto, debe resolver los archivos vinculados simbólicos e informar de los resultados en esos archivos mediante el identificador URI resuelto.

Validar tu archivo SARIF

Puedes verificar si un archivo SARIF es compatible con el code scanning si lo pruebas contra las reglas de ingestión de GitHub. Para obtener más información, visite el validador de SARIF de Microsoft.

En cada archivo SARIF comprimido con gzip, la carga de SARIF admite un tamaño máximo de 10 MB. Se rechazarán las cargas que superen este límite. Si el archivo SARIF es demasiado grande porque contiene demasiados resultados, debe actualizar la configuración para centrarse en los resultados de las reglas o consultas más importantes. Para más información, consulta El archivo de resultados SARIF es demasiado grande.

Code scanning admite la carga de un número máximo de entradas para los objetos de datos de la tabla siguiente. Si alguno de estos objetos supera su valor máximo, se rechaza el archivo SARIF. Para algunos objetos, hay un límite adicional en el número de valores que se mostrarán. Siempre que sea posible, se muestran los valores más importantes. Para sacar el máximo partido del análisis cuando incluye datos por encima de los límites admitidos, intente optimizar la configuración de análisis (por ejemplo, para la herramienta CodeQL, identifique y deshabilite las consultas más ruidosas). Para más información, consulta Los resultados de SARIF superan uno o más límites.

Datos de SARIF	Valores máximos	Límites de truncamiento de datos
Ejecuciones por archivo	20	None
Resultados por ejecución	25 000	Solo se incluirán los 5000 resultados principales, priorizados por gravedad.
Reglas por ejecución	25 000	None
Extensiones de herramienta por ejecución	100	None
Ubicaciones de flujo de subprocesos por resultado	10 000	Solo se incluirán las 1000 ubicaciones principales de flujo de subprocesos mediante la priorización.
Ubicación por resultado	1,000	Solo se incluirán 100 ubicaciones.
Etiquetas por regla	20	Solo se incluirán 10 etiquetas.
Límite de alertas	1 000 000	Ninguno

Para obtener más información sobre otros errores, consulta Solución de problemas de carga de archivos SARIF.

Carga de más de un archivo SARIF para una confirmación

Puedes cargar varios archivos SARIF para la misma confirmación y mostrar los datos de cada archivo como resultados del code scanning. Cuando cargas varios archivos de SARIF en una confirmación, debes indicar una "Categoría" para cada análisis. La forma de especificar una categoría varía de acuerdo con el método de análisis:

Si usa directamente CodeQL CLI, puede enviar el argumento --sarif-category al comando codeql database analyze cuando genere los archivos SARIF. Para más información, consulta Acerca de la CLI de CodeQL.
Utilice GitHub Actions con codeql-action/analyze para que la categoría se establezca automáticamente a partir del nombre del flujo de trabajo y las variables de matriz (normalmente, es language). Para ignorarlo, especifica una entrada category para la acción, lo que resulta útil cuando analiza diferentes secciones de un repositorio único en un flujo de trabajo individual.
Si GitHub Actions para cargar los resultados de otras herramientas de análisis estático, debe especificar una entrada en category si carga más de un archivo de resultados para la misma herramienta en un flujo de trabajo. Para más información, consulta Subir un archivo SARIF a GitHub.
Si no usa ninguno de estos enfoques, debe especificar un runAutomationDetails.id único en cada archivo SARIF que se va a cargar. Para más información sobre esta propiedad, consulta el objeto runAutomationDetails .

Si cargas un archivo de SARIF para una confirmación con la misma categoría y desde la misma herramienta, los resultados anteriores se sobreescribirán. Sin embargo, si intentas cargar varios archivos SARIF para la misma herramienta y categoría en una ejecución de flujo de trabajo de GitHub Actions sencilla, esta configuración errónea se detectará y la ejecución fallará.

Propiedades compatibles de archivo de salida SARIF

Si utilizas un motor de análisis de código diferente a CodeQL, puedes revisar las propiedades SARIF compatibles para optimizar cómo aparecerán los resultados de tu análisis en GitHub.

Note

Debes proporcionar un valor explícito para cualquier propiedad marcada como "obligatoria". La cadena vacía no se admite para las propiedades necesarias.

Puedes cargar cualquier archivo de salida SARIF 2.1.0 válido, sin embargo, code scanning utilizará únicamente las siguientes propiedades compatibles.

Objecto `sarifLog`

Nombre	Obligatorio	Descripción
`$schema`		URI del esquema de JSON SARIF para la versión 2.1.0. Por ejemplo, `https://json.schemastore.org/sarif-2.1.0.json`.
`version`		Code scanning solo admite la versión `2.1.0` de SARIF.
`runs[]`		Un archivo SARIF contiene una matriz de una o varias ejecuciones. Cada ejecución representa una sola ejecución de una herramienta de análisis. Para obtener más información sobre un `run`, consulte el objeto `run`.

Objecto `run`

Code scanning usa el objeto run para filtrar resultados por herramienta y proporcionar información sobre el origen de un resultado. El objeto run contiene el objeto de componente de herramienta tool.driver, que contiene información sobre la herramienta que generó los resultados. Cada run puede tener resultados para una sola herramienta de análisis.

Nombre	Obligatorio	Descripción
`tool.driver`		Un objeto `toolComponent` que describe la herramienta de análisis. Para obtener más información, consulte el objeto `toolComponent`.
`tool.extensions[]`		Una matriz de objetos `toolComponent` que representan todos los complementos o extensiones usados por la herramienta durante el análisis. Para obtener más información, consulte el objeto `toolComponent`.
`invocation.workingDirectory.uri`		Este campo solo se utiliza cuando no se proporciona `checkout_uri` (solo API de carga de SARIF) o `checkout_path` (solo GitHub Actions). El valor se usa para convertir URI absolutos usados en `physicalLocation` objetos en URI relativos. Para obtener más información, consulta Especificar la raíz para los archivos de origen.
`results[]`		Resultados de la herramienta de análisis. Code scanning muestra los resultados en GitHub. Para obtener más información, consulte el objeto `result`.

Objecto `toolComponent`

Nombre	Obligatorio	Descripción
`name`		Nombre de la herramienta de análisis. Code scanning muestra el nombre en GitHub para permitirte filtrar los resultados por herramienta.
`version`		Versión de la herramienta de análisis. Code scanning utiliza el número de versión para rastrear cuando los resultados pudieran haber cambiado debido al cambio de versión en la herramienta en vez de debido a un cambio del código que se analiza. Si el archivo SARIF incluye el campo `semanticVersion`, el code scanning no usa `version`.
`semanticVersion`		Versión de la herramienta de análisis, especificada por el formato Versionamiento Semántico 2.0. Code scanning utiliza el número de versión para rastrear cuando los resultados pudieran haber cambiado debido al cambio de versión en la herramienta en vez de debido a un cambio del código que se analiza. Si el archivo SARIF incluye el campo `semanticVersion`, el code scanning no usa `version`. Para obtener más información, consulta Versionamiento Semántico 2.0.0 en la documentación sobre Versionamiento Semántico.
`rules[]`		Matriz de objetos `reportingDescriptor` que representan reglas. La herramienta de análisis utiliza reglas para encontrar problemas en el código que se analiza. Para obtener más información, consulte el objeto `reportingDescriptor`.

Objecto `reportingDescriptor`

Aquí es donde almacenas los detalles de las reglas que se ejecutan durante el análisis. La información de estos objetos debe cambiar con poca frecuencia, normalmente al actualizar la herramienta. Para obtener más información, consulta Descripción de las reglas y los resultados más arriba.

Nombre	Obligatorio	Descripción
`id`		Identificador único para la regla. Al `id` se hace referencia desde otras secciones del archivo SARIF, y se puede usar en el code scanning para mostrar las URL en GitHub.
`name`		Nombre de la regla. Code scanning muestra el nombre para permitir que se filtren los resultados por regla en GitHub. Tiene un límite de 255 caracteres.
`shortDescription.text`		Descripción concisa de la regla. Code scanning muestra la descripción corta en GitHub junto a los resultados asociados. Tiene un límite de 1024 caracteres.
`fullDescription.text`		Una descripción de la regla. Code scanning muestra la descripción completa en GitHub junto a los resultados asociados. Tiene un límite de 1024 caracteres.
`defaultConfiguration.level`		Nivel de gravedad predeterminado de la regla. Code scanning utiliza niveles de severidad para ayudarte a entender cuán crítico es el resultado de una regla. `defaultConfiguration.level` se establece en `warning` de manera predeterminada. Sin embargo, puede invalidar el nivel predeterminado de una regla estableciendo el atributo `level` en el objeto `result` asociado al resultado. Para obtener más información, consulte la documentación en el `result`objeto. Los valores válidos para `defaultConfiguration.level` son: `note`, `warning` y `error`.
`help.text`		Documentación de la regla con formato de texto. Code scanning muestra esta documentación de ayuda junto a los resultados asociados.
`help.markdown`		(Recomendable) Documentación de la regla con formato de Markdown. Code scanning muestra esta documentación de ayuda junto a los resultados asociados. Cuando `help.markdown` está disponible, se muestra en lugar de `help.text`.
`properties.tags[]`		Una matriz de cadenas. Code scanning usa `tags` para permitirle filtrar resultados en GitHub. Por ejemplo, es posible filtrar todos los resultados que tengan la etiqueta `security`.
`properties.precision`		(Recomendable) Cadena que indica con qué frecuencia se cumplen los resultados indicados por esta regla. Por ejemplo, si una regla tiene una tasa alta de falsos positivos, la precisión debería ser `low`. Code scanning ordena los resultados de acuerdo con su precisión en GitHub para que aquellos con el `level` y el `precision` más altos aparezcan primero. Puede ser `very-high`, `high`, `medium` o `low`.
`properties.problem.severity`		(Recomendable) Cadena que indica el nivel de gravedad de las alertas generadas por una consulta que no sea de seguridad. Esto, junto con la propiedad `properties.precision`, determina si los resultados se muestran de manera predeterminada en GitHub para que los resultados con el `problem.severity` y el `precision` más altos aparezcan primero. Puede ser de tipo `error`, `warning` o `recommendation`.
`properties.security-severity`		(Recomendado solo para las reglas de seguridad) Si incluye un valor para este campo, los resultados de la regla se tratan como resultados de seguridad. Cadena que representa una puntuación que indica el nivel de gravedad, un valor superior a entre 0,0 y 10,0, de las consultas de seguridad (`@tags` incluye `security`). Esto, junto con la propiedad `properties.precision`, determina si los resultados se muestran de manera predeterminada en GitHub para que los resultados con el `security-severity` y el `precision` más altos aparezcan primero. Code scanning traduce las puntuaciones numéricas de la siguiente manera: más de 9,0 es `critical`, entre 7,0 y 8,9 es `high`, entre 4,0 y 6,9 es `medium` y desde 0,1 a 3,9 es `low`. Un valor de 0,0 o cualquier otro valor fuera del intervalo especificado se considera que no tiene gravedad de seguridad.

Objecto `result`

Cada objeto result contiene detalles de una alerta en el código base. Dentro del objeto results, puedes hacer referencia a la regla que ha detectado la alerta. Para obtener más información, consulta Descripción de las reglas y los resultados más arriba.

Puedes comprobar que las propiedades SARIF tienen el tamaño compatible para la carga y que el archivo es compatible con el examen de código. Para más información, consulta "Soporte de SARIF para escaneo de código".

Nombre	Obligatorio	Descripción
`ruleId`		Identificador único de la regla (`reportingDescriptor.id`). Para obtener más información, consulte el objeto `reportingDescriptor`. Code scanning utiliza el identificador de reglas para filtrar los resultados por regla en GitHub.
`ruleIndex`		Índice de la regla asociada (objeto `reportingDescriptor`) en la matriz `rules` de componentes de herramienta. Para obtener más información, consulte el objeto `run`. El rango permitido para esta propiedad de 0 to 2^63 - 1.
`rule`		Referencia usada para buscar la regla (descriptor de informes) de este resultado. Para obtener más información, consulte el objeto `reportingDescriptor`.
`level`		Gravedad del resultado. Este nivel invalida la severidad predeterminada que se define en la regla. Code scanning utiliza el nivel para filtrar los resultados en GitHub por severidad.
`message.text`		Mensaje que describe el resultado. Code scanning muestra el texto del mensaje como el título del resultado. Se mostrará únicamente la primera oración del mensaje cuando el espacio visible esté limitado.
`locations[]`		Conjunto de ubicaciones donde se detectó el resultado (hasta un máximo de 10). Sólo se deberá incluir una ubicación a menos de que el problema solo pueda corregirse realizando un cambio en cada ubicación especificada. Nota: Se requiere al menos una ubicación para que code scanning muestre el resultado. Code scanning utilizará esta propiedad para decidir qué archivo anotar con el resultado. Únicamente si se utiliza el primer valor de este arreglo. Se ignorará al resto de los otros valores.
`partialFingerprints`		Conjunto de cadenas usadas para realizar un seguimiento de la identidad única del resultado. Code scanning usa `partialFingerprints` para identificar con precisión los resultados que son iguales en todas las confirmaciones y ramas. Code scanning intentará usar `partialFingerprints` si están presentes. Si va a cargar archivos SARIF de terceros con `upload-action`, la acción creará `partialFingerprints` automáticamente cuando no se incluyan en el archivo SARIF. Para obtener más información, consulta Proporcionar datos para realizar un seguimiento de las alertas de análisis de código entre ejecuciones. Nota: Code scanning solo usa `primaryLocationLineHash`.
`codeFlows[].threadFlows[].locations[]`		Matriz de objetos `location` para un objeto `threadFlow`, que describe el progreso de un programa a través de un subproceso de ejecución. Un objeto `codeFlow` describe un patrón de ejecución de código utilizado para detectar un resultado. Si se proporcionan flujos de código, code scanning los expandirá en GitHub para el resultado relevante. Para obtener más información, consulte el objeto `location`.
`relatedLocations[]`		Un conjunto de ubicaciones relevantes para el resultado. Code scanning vinculará las ubicaciones cuando se incorporen en el mensaje de resultado. Para obtener más información, consulte el objeto `location`.

Objecto `location`

Una ubicación dentro de un artefacto de programación, tal como un archivo en el repositorio o un archivo que se generó durante una compilación.

Nombre	Obligatorio	Descripción
`location.id`		Identificador único que distingue esta ubicación de todas las demás ubicaciones dentro de un único objeto de resultado. El rango permitido para esta propiedad de 0 to 2^63 - 1.
`location.physicalLocation`		Identifica el artefacto y la región. Para obtener más información, consulte `physicalLocation`.
`location.message.text`		Mensaje relevante para la ubicación.

Objecto `physicalLocation`

Nombre	Obligatorio	Descripción
`artifactLocation.uri`		URI que indica la ubicación de un artefacto, normalmente un archivo del repositorio o generado durante una compilación. Para obtener los mejores resultados, se recomienda que se trata de una ruta de acceso relativa de la raíz del repositorio de GitHub que se está analizando. Por ejemplo, `src/main.js`. Para obtener más información sobre los URI de artefacto, consulta Especificación de la raíz para los archivos de origen.
`region.startLine`		Número de línea del primer carácter de la región.
`region.startColumn`		Número de columna del primer carácter de la región.
`region.endLine`		Número de línea del último carácter de la región.
`region.endColumn`		Número de columna del carácter que sigue al final de la región.

Objecto `runAutomationDetails`

El objeto runAutomationDetails contiene información que especifica la identidad de una ejecución.

Nombre	Obligatorio	Descripción
`id`		Cadena que identifica la categoría del análisis y el identificador de ejecución. Utilízala si quieres cargar varios archivos SARIF para la misma herramienta y confirmación, pero que se realice en diferentes lenguajes o partes del código.

El uso del objeto runAutomationDetails es opcional.

El campo id puede incluir una categoría de análisis y un identificador de ejecución. No usamos la parte del identificador de ejecución del campo id, pero la almacenamos.

Utiliza la categoría para distinguir entre los diversos análisis de la misma herramienta o confirmación, pero cuando se llevan a cabo en diferentes lenguajes o en partes diferentes del código. Utiliza la ID de ejecución para identificar la ejecución específica del análisis, tal como la fecha en la que este se ejecutó.

id se interpreta como category/run-id. Si id no contiene ninguna barra diagonal (/), la cadena completa es la run_id y la category está vacía. De lo contrario, category será todo lo que aparezca en la cadena hasta la última barra diagonal, y run_id el resto.

`id`	category	`run_id`
my-analysis/tool1/2022-01-02	my-analysis/tool1	2022-01-02
my-analysis/tool1/	my-analysis/tool1	None
my-analysis for tool1	None	my-analysis for tool1

La ejecución con un id de "my-analysis/tool1/2021-02-01" pertenece a la categoría "my-analysis/tool1".
La ejecución con un id de "my-analysis/tool1/" pertenece a la cateogría "my-analysis/tool1", pero no se distingue de otras ejecuciones de esa categoría.
La ejecución cuyo id es "my-analysis for tool1 " tiene un identificador único, pero no se puede inferir que pertenezca a alguna categoría.

Para obtener más información sobre el objeto runAutomationDetails y el campo id, consulte Objeto runAutomationDetails en la documentación de OASIS.

Nota que el resto de los campos compatibles se ignorarán.

Ejemplos de archivo de salida SARIF

Estos ejemplos de archivos de salida SARIF muestran las propiedades compatibles y los valores de ejemplo.

Ejemplo con las propiedades mínimas requeridas

Este archivo de salida SARIF tiene valores de ejemplo para mostrar las propiedades mínimas requeridas para que los resultados de code scanning funcionen como se espera. Si eliminas cualquier propiedad u omites valores, o si usas una cadena vacía, estos datos no se mostrarán correctamente ni se sincronizarán en GitHub.

{
  "$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"
          }
        }
      ]
    }
  ]
}

Guía relativa de URI para productores SARIF

Este archivo de salida SARIF tiene un ejemplo de valores para el campo originalUriBaseIds, que muestra las propiedades mínimas necesarias que debe incluir un productor SARIF al usar referencias de URI relativas.