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 obtener más información, vea «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 obtener más información, vea «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, vea "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 obtener más información, vea «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 obtener más información, vea «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 obtener más información, vea «Los resultados de SARIF superan uno o más límites».

Para obtener más información sobre otros errores, consulte "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 obtener más información, vea «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 obtener más información, vea «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 "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.

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, consulte "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 resultobjeto. 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.

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

Ejemplo que muestra todas las propiedades compatibles con SARIF

Este archivo de salida SARIF tiene valores ejemplo para mostrar todas las propiedades de SARIF compatibles con code scanning.

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