{"meta":{"title":"Soporte de SARIF para escaneo de código","intro":"Asegúrese de que los archivos SARIF de herramientas de terceros cumplen los estándares de GitHub.","product":"Seguridad y calidad del código","breadcrumbs":[{"href":"/es/code-security","title":"Seguridad y calidad del código"},{"href":"/es/code-security/reference","title":"Referencia"},{"href":"/es/code-security/reference/code-scanning","title":"Análisis de código"},{"href":"/es/code-security/reference/code-scanning/sarif-files","title":"Archivos SARIF"},{"href":"/es/code-security/reference/code-scanning/sarif-files/sarif-support-for-code-scanning","title":"Soporte de SARIF"}],"documentType":"article"},"body":"# Soporte de SARIF para escaneo de código\n\nAsegúrese de que los archivos SARIF de herramientas de terceros cumplen los estándares de GitHub.\n\nGitHub puede analizar los archivos SARIF generados por herramientas de terceros para mostrar las alertas de code scanning en repositorios. Para más información, consulta [Acerca de los archivos SARIF para el examen de código](/es/code-security/concepts/code-scanning/sarif-files).\n\nEn este artículo se resaltan las propiedades clave de los archivos SARIF para ayudarle a cargar archivos SARIF que cumplen con los requisitos de GitHub y que se pueden convertir en alertas útiles.\n\nSi 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.\n\n## Datos para evitar alertas duplicadas\n\nCada 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.\n\n### Rutas de archivo coherentes\n\nLa 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.\n\n### Generación de huellas digitales\n\nGitHub 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](https://docs.oasis-open.org/sarif/sarif/v2.1.0/cs01/sarif-v2.1.0-cs01.html#_Toc16012611) en la documentación de OASIS.\n\nLos 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 obtener más información sobre cómo cargar los resultados, consulte [Subir un archivo SARIF a GitHub](/es/code-security/code-scanning/integrating-with-code-scanning/uploading-a-sarif-file-to-github).\n\nSi 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: . Para obtener más información sobre la API, consulte [Puntos de conexión de la API de REST para el análisis de código](/es/rest/code-scanning/code-scanning#upload-an-analysis-as-sarif-data).\n\n## Reglas y resultados\n\nLos archivos SARIF admiten reglas y resultados. La información almacenada en estos elementos es similar, pero sirve para diferentes propósitos.\n\n* 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.\n* 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.\n\nAl 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.\n\n## Ubicaciones de archivos de origen\n\nEspecificar 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.\n\nEsta 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.\n\nCode 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.\n\nPara que se muestre en una comprobación de solicitud de incorporación de cambios, una alerta debe cumplir todas las condiciones siguientes:\n\n* 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.\n* 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.\n\nEl objeto `physicalLocation` de un archivo SARIF enviado identifica las líneas de código de una alerta. Para obtener más información, consulte el objeto [`physicalLocation`](#physicallocation-object).\n\n### Ubicación raíz de los archivos de origen\n\nCode 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.\n\nPuedes proporcionar la raíz de origen para la conversión de URI absolutos a relativos de una de las siguientes maneras.\n\n* [\n `checkout_path` Entrada ](https://github.com/github/codeql-action/blob/c2c0a2908e95769d01b907f9930050ecb5cf050d/analyze/action.yml#L44-L47) para la acción `github/codeql-action/analyze`\n* ```\n Parámetro `checkout_uri` al punto de conexión de la API de carga de SARIF. Para más información, consulta [AUTOTITLE](/rest/code-scanning/code-scanning#upload-an-analysis-as-sarif-data).\n ```\n* [\n `invocations[0].workingDirectory.uri` Propiedad ](https://docs.oasis-open.org/sarif/sarif/v2.1.0/csprd01/sarif-v2.1.0-csprd01.html#_Toc9244365) en el objeto `run` del archivo SARIF\n\nSi 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.\n\nPor ejemplo, un archivo SARIF se carga mediante una raíz de origen de `file:///github/workspace`.\n\n```shell\n# Conversion of absolute URIs to relative URIs for location artifacts\n\nfile:///github/workspace/src/main.go -> src/main.go\nfile:///tmp/go-build/tmp.go -> file:///tmp/go-build/tmp.go\n```\n\nEl archivo se carga correctamente, ya que ambos URI absolutos usan el mismo esquema de URI que la raíz de origen.\n\n### Resolución de vínculo simbólico\n\nSi 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.\n\n## Compatibilidad de archivos\n\n\n\nPuedes 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](https://sarifweb.azurewebsites.net/).\n\nEn 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](/es/code-security/how-tos/scan-code-for-vulnerabilities/troubleshooting/troubleshooting-sarif-uploads/file-too-large).\n\nCode 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](/es/code-security/how-tos/scan-code-for-vulnerabilities/troubleshooting/troubleshooting-sarif-uploads/results-exceed-limit).\n\n
\n\n| **Datos de SARIF** | **Valores máximos** | **Límites de truncamiento de datos** |\n| ------------------------------------------------- | :-----------------: | ---------------------------------------------------------------------------------------------------- |\n| Ejecuciones por archivo | 20 | None |\n| Resultados por ejecución | 25 000 | Solo se incluirán los 5000 resultados principales, priorizados por gravedad. |\n| Reglas por ejecución | 25 000 | None |\n| Extensiones de herramienta por ejecución | 100 | None |\n| 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. |\n| Ubicación por resultado | 1,000 | Solo se incluirán 100 ubicaciones. |\n| Etiquetas por regla | 20 | Solo se incluirán 10 etiquetas. |\n| Límite de alertas | 1 000 000 | Ninguno |\n\n
\n\nPara obtener información sobre otros errores, consulte [Solución de problemas de carga de archivos SARIF](/es/code-security/how-tos/scan-code-for-vulnerabilities/troubleshooting/troubleshooting-sarif-uploads).\n\n## Propiedades compatibles\n\nSi 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.\n\n> \\[!NOTE]\n> Debe proporcionar un valor explícito para cualquier propiedad marcada como \"obligatoria\". La cadena vacía no se admite para las propiedades necesarias.\n\nPuedes cargar cualquier archivo de salida SARIF 2.1.0 válido, sin embargo, code scanning utilizará únicamente las siguientes propiedades compatibles.\n\n### Objeto `sarifLog`\n\n| Nombre | Obligatorio | Description |\n| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\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`. |\n| `version` | | Code scanning solo admite la versión `2.1.0` de SARIF. |\n| `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 `run`, consulte el objeto [`run`](#run-object). |\n\n### Objeto `run`\n\nCode 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.\n\n| Nombre | Obligatorio | Description |\n| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `tool.driver` | | Un objeto `toolComponent` que describe la herramienta de análisis. Para obtener más información, consulte el objeto [`toolComponent`](#toolcomponent-object). |\n| `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`](#toolcomponent-object). |\n| `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 objetos [`physicalLocation`](#physicallocation-object) en URI relativos. Para obtener más información, consulte [Especificación de la raíz para los archivos de origen](#root-location-for-source-files). |\n| `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`](#result-object). |\n\n### Objeto `toolComponent`\n\n| Nombre | Obligatorio | Description |\n| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `name` | | Nombre de la herramienta de análisis. Code scanning muestra el nombre en GitHub para permitirte filtrar los resultados por herramienta. |\n| `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`. |\n| `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](https://semver.org/) en la documentación sobre Versionamiento Semántico. |\n| `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`](#reportingdescriptor-object). |\n\n### Objeto `reportingDescriptor`\n\nAquí 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, consulte [Reglas y resultados](#rules-and-results) anteriores.\n\n| Nombre | Obligatorio | Description |\n| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `id` | | Identificador único de 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. |\n| `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. |\n| `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. |\n| `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. |\n| `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. |\n\n```\n `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 del objeto [`result`](#result-object). Los valores válidos para `defaultConfiguration.level` son: `note`, `warning` y `error`.\n```\n\n\\| `help.text` | | Documentación de la regla con formato de texto. Code scanning muestra esta documentación de ayuda junto a los resultados asociados.\n\\| `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`.\n\\| `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`.\n\\| `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`.\n\\| `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`.\n\\| `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.\n\n### Objeto `result`\n\nCada 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, consulte [Reglas y resultados](#rules-and-results) anteriores.\n\n| Nombre | Obligatorio | Description |\n| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `ruleId` | | Identificador único de la regla (`reportingDescriptor.id`). Para obtener más información, consulte el objeto [`reportingDescriptor`](#reportingdescriptor-object). Code scanning utiliza el identificador de reglas para filtrar los resultados por regla en GitHub. |\n| `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`](#run-object). El rango permitido para esta propiedad de 0 to 2^63 - 1. |\n| `rule` | | Referencia usada para buscar la regla (descriptor de informes) de este resultado. Para obtener más información, consulte el objeto [`reportingDescriptor`](#reportingdescriptor-object). |\n| `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. |\n| `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. |\n| `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. |\n\n```\n **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.\n```\n\n\\| `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, consulte [Proporcionar datos para realizar un seguimiento de las alertas de análisis de código entre ejecuciones](#data-for-preventing-duplicated-alerts).\n**Nota:** Code scanning solo usa `primaryLocationLineHash`.\n\\| `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`](#location-object).\n\\| `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`](#location-object).\n\n### Objeto `location`\n\nUna 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.\n\n| Nombre | Obligatorio | Description |\n| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\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. |\n| `location.physicalLocation` | | Identifica el artefacto y la región. Para obtener más información, consulte [`physicalLocation`](#physicallocation-object). |\n| `location.message.text` | | Mensaje relevante para la ubicación. |\n\n### Objeto `physicalLocation`\n\n| Nombre | Obligatorio | Description |\n| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\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 desde 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, consulte [Especificación de la raíz para los archivos de origen](#root-location-for-source-files). |\n| `region.startLine` | | Número de línea del primer carácter de la región. |\n| `region.startColumn` | | Número de columna del primer carácter de la región. |\n| `region.endLine` | | Número de línea del último carácter de la región. |\n| `region.endColumn` | | Número de columna del carácter que sigue al final de la región. |\n\n### Objeto `runAutomationDetails`\n\nEl objeto `runAutomationDetails` contiene información que especifica la identidad de una ejecución.\n\n| Nombre | Obligatorio | Description |\n| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\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. |\n\nEl uso del objeto `runAutomationDetails` es opcional.\n\nEl 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.\n\nUtiliza 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ó.\n\n```\n `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.\n```\n\n| `id` | categoría | `run_id` |\n| ---------------------------- | ----------------- | ---------------------- |\n| my-analysis/tool1/2022-01-02 | my-analysis/tool1 | 2022-01-02 |\n| my-analysis/tool1/ | my-analysis/tool1 | Ninguno |\n| mi-análisis para tool1 | Ninguno | mi-análisis para tool1 |\n\n* La ejecución con un `id` de \"my-analysis/tool1/2021-02-01\" pertenece a la categoría \"my-analysis/tool1\".\n* 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.\n* 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.\n\nPara obtener más información sobre el objeto `runAutomationDetails` y el campo `id`, consulte [Objeto runAutomationDetails](https://docs.oasis-open.org/sarif/sarif/v2.1.0/cs01/sarif-v2.1.0-cs01.html#_Toc16012479) en la documentación de OASIS.\n\nNota que el resto de los campos compatibles se ignorarán.\n\n## Ejemplos de archivo de salida SARIF\n\nEstos ejemplos de archivos de salida SARIF muestran las propiedades compatibles y los valores de ejemplo.\n\n### Ejemplo con las propiedades mínimas requeridas\n\nEste 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.\n\n```json\n{\n \"$schema\": \"https://json.schemastore.org/sarif-2.1.0.json\",\n \"version\": \"2.1.0\",\n \"runs\": [\n {\n \"tool\": {\n \"driver\": {\n \"name\": \"Tool Name\",\n \"rules\": [\n {\n \"id\": \"R01\"\n ...\n \"properties\" : {\n \"id\" : \"java/unsafe-deserialization\",\n \"kind\" : \"path-problem\",\n \"name\" : \"...\",\n \"problem.severity\" : \"error\",\n \"security-severity\" : \"9.8\",\n }\n }\n ]\n }\n },\n \"results\": [\n {\n \"ruleId\": \"R01\",\n \"message\": {\n \"text\": \"Result text. This result does not have a rule associated.\"\n },\n \"locations\": [\n {\n \"physicalLocation\": {\n \"artifactLocation\": {\n \"uri\": \"fileURI\"\n },\n \"region\": {\n \"startLine\": 2,\n \"startColumn\": 7,\n \"endColumn\": 10\n }\n }\n }\n ],\n \"partialFingerprints\": {\n \"primaryLocationLineHash\": \"39fa2ee980eb94b0:1\"\n }\n }\n ]\n }\n ]\n}\n```\n\n### Guía de URI relativos para productores de SARIF\n\nEste 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 de SARIF al usar referencias de URI relativos.\n\n> \\[!NOTE]\n> Aunque esta propiedad no es necesaria en GitHub para que se muestren los resultados de code scanning correctamente, sí lo es para generar una salida de SARIF válida cuando se utilizan referencias de URI relativos.\n\n```json\n{\n \"$schema\": \"https://json.schemastore.org/sarif-2.1.0.json\",\n \"version\": \"2.1.0\",\n \"runs\": [\n {\n \"tool\": {\n \"driver\": {\n \"name\": \"Tool Name\",\n \"rules\": [\n {\n \"id\": \"R01\"\n ...\n \"properties\" : {\n \"id\" : \"java/unsafe-deserialization\",\n \"kind\" : \"path-problem\",\n \"name\" : \"...\",\n \"problem.severity\" : \"error\",\n \"security-severity\" : \"9.8\",\n }\n }\n ]\n }\n },\n \"originalUriBaseIds\": {\n \"PROJECTROOT\": {\n \"uri\": \"file:///C:/Users/Mary/code/TheProject/\",\n \"description\": {\n \"text\": \"The root directory for all project files.\"\n }\n },\n \"%SRCROOT%\": {\n \"uri\": \"src/\",\n \"uriBaseId\": \"PROJECTROOT\",\n \"description\": {\n \"text\": \"The root of the source tree.\"\n }\n }\n },\n \"results\": [\n {\n \"ruleId\": \"R01\",\n \"message\": {\n \"text\": \"Result text. This result does not have a rule associated.\"\n },\n \"locations\": [\n {\n \"physicalLocation\": {\n \"artifactLocation\": {\n \"uri\": \"fileURI\",\n \"uriBaseId\": \"%SRCROOT%\"\n },\n \"region\": {\n \"startLine\": 2,\n \"startColumn\": 7,\n \"endColumn\": 10\n }\n }\n }\n ],\n \"partialFingerprints\": {\n \"primaryLocationLineHash\": \"39fa2ee980eb94b0:1\"\n }\n }\n ]\n }\n ]\n}\n```\n\n### Ejemplo que muestra todas las propiedades compatibles con SARIF\n\nEste archivo de salida SARIF tiene valores ejemplo para mostrar todas las propiedades de SARIF compatibles con code scanning.\n\n```json\n{\n \"$schema\": \"https://json.schemastore.org/sarif-2.1.0.json\",\n \"version\": \"2.1.0\",\n \"runs\": [\n {\n \"tool\": {\n \"driver\": {\n \"name\": \"Tool Name\",\n \"semanticVersion\": \"2.0.0\",\n \"rules\": [\n {\n \"id\": \"3f292041e51d22005ce48f39df3585d44ce1b0ad\",\n \"name\": \"js/unused-local-variable\",\n \"shortDescription\": {\n \"text\": \"Unused variable, import, function or class\"\n },\n \"fullDescription\": {\n \"text\": \"Unused variables, imports, functions or classes may be a symptom of a bug and should be examined carefully.\"\n },\n \"defaultConfiguration\": {\n \"level\": \"note\"\n },\n \"properties\": {\n \"tags\": [\n \"maintainability\"\n ],\n \"precision\": \"very-high\"\n }\n },\n {\n \"id\": \"d5b664aefd5ca4b21b52fdc1d744d7d6ab6886d0\",\n \"name\": \"js/inconsistent-use-of-new\",\n \"shortDescription\": {\n \"text\": \"Inconsistent use of 'new'\"\n },\n \"fullDescription\": {\n \"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'.\"\n },\n \"properties\": {\n \"tags\": [\n \"reliability\",\n \"correctness\",\n \"language-features\"\n ],\n \"precision\": \"very-high\"\n }\n },\n {\n \"id\": \"R01\"\n }\n ]\n }\n },\n \"automationDetails\": {\n \"id\": \"my-category/\"\n },\n \"results\": [\n {\n \"ruleId\": \"3f292041e51d22005ce48f39df3585d44ce1b0ad\",\n \"ruleIndex\": 0,\n \"message\": {\n \"text\": \"Unused variable foo.\"\n },\n \"locations\": [\n {\n \"physicalLocation\": {\n \"artifactLocation\": {\n \"uri\": \"main.js\",\n \"uriBaseId\": \"%SRCROOT%\"\n },\n \"region\": {\n \"startLine\": 2,\n \"startColumn\": 7,\n \"endColumn\": 10\n }\n }\n }\n ],\n \"partialFingerprints\": {\n \"primaryLocationLineHash\": \"39fa2ee980eb94b0:1\",\n \"primaryLocationStartColumnFingerprint\": \"4\"\n }\n },\n {\n \"ruleId\": \"d5b664aefd5ca4b21b52fdc1d744d7d6ab6886d0\",\n \"ruleIndex\": 1,\n \"message\": {\n \"text\": \"Function resolvingPromise is sometimes invoked as a constructor (for example [here](1)), and sometimes as a normal function (for example [here](2)).\"\n },\n \"locations\": [\n {\n \"physicalLocation\": {\n \"artifactLocation\": {\n \"uri\": \"src/promises.js\",\n \"uriBaseId\": \"%SRCROOT%\"\n },\n \"region\": {\n \"startLine\": 2\n }\n }\n }\n ],\n \"partialFingerprints\": {\n \"primaryLocationLineHash\": \"5061c3315a741b7d:1\",\n \"primaryLocationStartColumnFingerprint\": \"7\"\n },\n \"relatedLocations\": [\n {\n \"id\": 1,\n \"physicalLocation\": {\n \"artifactLocation\": {\n \"uri\": \"src/ParseObject.js\",\n \"uriBaseId\": \"%SRCROOT%\"\n },\n \"region\": {\n \"startLine\": 2281,\n \"startColumn\": 33,\n \"endColumn\": 55\n }\n },\n \"message\": {\n \"text\": \"here\"\n }\n },\n {\n \"id\": 2,\n \"physicalLocation\": {\n \"artifactLocation\": {\n \"uri\": \"src/LiveQueryClient.js\",\n \"uriBaseId\": \"%SRCROOT%\"\n },\n \"region\": {\n \"startLine\": 166\n }\n },\n \"message\": {\n \"text\": \"here\"\n }\n }\n ]\n },\n {\n \"ruleId\": \"R01\",\n \"message\": {\n \"text\": \"Specifying both [ruleIndex](1) and [ruleId](2) might lead to inconsistencies.\"\n },\n \"level\": \"error\",\n \"locations\": [\n {\n \"physicalLocation\": {\n \"artifactLocation\": {\n \"uri\": \"full.sarif\",\n \"uriBaseId\": \"%SRCROOT%\"\n },\n \"region\": {\n \"startLine\": 54,\n \"startColumn\": 10,\n \"endLine\": 55,\n \"endColumn\": 25\n }\n }\n }\n ],\n \"relatedLocations\": [\n {\n \"id\": 1,\n \"physicalLocation\": {\n \"artifactLocation\": {\n \"uri\": \"full.sarif\"\n },\n \"region\": {\n \"startLine\": 81,\n \"startColumn\": 10,\n \"endColumn\": 18\n }\n },\n \"message\": {\n \"text\": \"here\"\n }\n },\n {\n \"id\": 2,\n \"physicalLocation\": {\n \"artifactLocation\": {\n \"uri\": \"full.sarif\"\n },\n \"region\": {\n \"startLine\": 82,\n \"startColumn\": 10,\n \"endColumn\": 21\n }\n },\n \"message\": {\n \"text\": \"here\"\n }\n }\n ],\n \"codeFlows\": [\n {\n \"threadFlows\": [\n {\n \"locations\": [\n {\n \"location\": {\n \"physicalLocation\": {\n \"region\": {\n \"startLine\": 11,\n \"endLine\": 29,\n \"startColumn\": 10,\n \"endColumn\": 18\n },\n \"artifactLocation\": {\n \"uriBaseId\": \"%SRCROOT%\",\n \"uri\": \"full.sarif\"\n }\n },\n \"message\": {\n \"text\": \"Rule has index 0\"\n }\n }\n },\n {\n \"location\": {\n \"physicalLocation\": {\n \"region\": {\n \"endColumn\": 47,\n \"startColumn\": 12,\n \"startLine\": 12\n },\n \"artifactLocation\": {\n \"uriBaseId\": \"%SRCROOT%\",\n \"uri\": \"full.sarif\"\n }\n }\n }\n }\n ]\n }\n ]\n }\n ],\n \"partialFingerprints\": {\n \"primaryLocationLineHash\": \"ABC:2\"\n }\n }\n ],\n \"columnKind\": \"utf16CodeUnits\"\n }\n ]\n}\n```"}