{"meta":{"title":"Prise en charge de SARIF pour l’analyse du code","intro":"Vérifiez que vos fichiers SARIF des outils tiers sont conformes aux normes GitHub.","product":"Sécurité et qualité du code","breadcrumbs":[{"href":"/fr/code-security","title":"Sécurité et qualité du code"},{"href":"/fr/code-security/reference","title":"Reference"},{"href":"/fr/code-security/reference/code-scanning","title":"Analyse du code"},{"href":"/fr/code-security/reference/code-scanning/sarif-files","title":"Fichiers SARIF"},{"href":"/fr/code-security/reference/code-scanning/sarif-files/sarif-support-for-code-scanning","title":"Prise en charge de SARIF"}],"documentType":"article"},"body":"# Prise en charge de SARIF pour l’analyse du code\n\nVérifiez que vos fichiers SARIF des outils tiers sont conformes aux normes GitHub.\n\nGitHub peut analyser les fichiers SARIF générés par des outils tiers pour afficher les alertes code scanning dans les référentiels. Pour plus d’informations, consultez « [À propos des fichiers SARIF pour l’analyse du code](/fr/code-security/concepts/code-scanning/sarif-files) ».\n\nCet article met en évidence les propriétés clés des fichiers SARIF pour vous aider à charger des fichiers SARIF qui répondent à GitHubet peuvent être convertis en alertes utiles.\n\nSi vous utilisez GitHub Actions avec le Workflow d’analyse CodeQL ou que vous utilisez CodeQL CLI, les résultats de code scanning utilisent automatiquement le sous-ensemble pris en charge de SARIF 2.1.0.\n\n## Données permettant d’empêcher les alertes dupliquées\n\nÀ chaque fois que les résultats d’une nouvelle analyse du code sont chargés, ils sont traités et les alertes sont ajoutées au référentiel. Pour empêcher les alertes en double pour le même problème, l’code scanning utilise des empreintes digitales pour faire correspondre les résultats entre les différentes exécutions afin qu’ils ne s’affichent qu’une seule fois dans la dernière exécution de la branche sélectionnée. Cela permet de faire correspondre les alertes à la ligne de code correcte quand les fichiers sont modifiés. La valeur `ruleId` d’un résultat doit être la même dans toute l’analyse.\n\n### Chemins de fichiers cohérents\n\nLe chemin de fichier doit être cohérent d’une exécution à l’autre pour permettre un calcul d’une empreinte digitale stable. Si les chemins de fichier diffèrent pour le même résultat, chaque fois qu’une nouvelle analyse est créée, l’ancienne est fermée. Il existe alors plusieurs alertes pour le même résultat.\n\n### Génération d’empreintes digitales\n\nGitHub utilise la propriété `partialFingerprints` de la norme OASIS pour détecter quand deux résultats sont logiquement identiques. Pour plus d’informations, consultez l’entrée [partialFingerprints property](https://docs.oasis-open.org/sarif/sarif/v2.1.0/cs01/sarif-v2.1.0-cs01.html#_Toc16012611) dans la documentation OASIS.\n\nLes fichiers SARIF créés par le Workflow d’analyse CodeQL ou à l’aide de CodeQL CLI comprennent des données d’empreinte digitale. Si vous chargez un fichier SARIF à l’aide de l’action `upload-sarif` et que ces données sont manquantes, GitHub tente de renseigner le champ `partialFingerprints` à partir des fichiers sources. Pour plus d’informations sur le chargement des résultats, consultez [Chargement d’un fichier SARIF sur GitHub](/fr/code-security/code-scanning/integrating-with-code-scanning/uploading-a-sarif-file-to-github).\n\nSi vous chargez un fichier SARIF sans données d’empreinte digitale en utilisant le point de terminaison de l’API `/code-scanning/sarifs`, les alertes d’code scanning sont traitées et affichées, mais les utilisateurs peuvent voir des alertes en double. Pour éviter de voir des alertes en double, vous devez calculer les données d’empreinte digitale et renseigner la propriété `partialFingerprints` avant de charger le fichier SARIF. Le script que l’action `upload-sarif` utilise peut être un point de départ utile : . Pour plus d’informations sur l’API, consultez [Points de terminaison d’API REST pour l’analyse de codes](/fr/rest/code-scanning/code-scanning#upload-an-analysis-as-sarif-data).\n\n## Règles et résultats\n\nLes fichiers SARIF prennent en charge les règles et les résultats. Les informations stockées dans ces éléments sont similaires, mais ont des buts différents.\n\n* Les règles sont un tableau d’objets `reportingDescriptor` qui sont inclus dans l’objet `toolComponent`. C’est là que vous stockez les détails des règles exécutées pendant l’analyse. Les informations contenues dans ces objets doivent changer rarement, généralement lorsque vous mettez à jour l’outil.\n* Les résultats sont stockés sous forme d’une série d’objets `result` sous `results` dans l’objet `run`. Chaque objet `result` contient les détails d’une alerte dans le codebase. Dans l’objet `results`, vous pouvez référencer la règle qui a détecté l’alerte.\n\nLorsque vous comparez les fichiers SARIF générés en analysant différents codebases avec le même outil et les mêmes règles, vous devriez voir des différences dans les résultats des analyses, mais pas dans les règles.\n\n## Emplacements des fichiers sources\n\nLa spécification de l’emplacement des fichiers sources et des lignes de code garantit que les alertes d’analyse de code sont affichées avec précision dans le fichier contenant le problème identifié, ce qui permet une résolution ciblée du problème.\n\nCette précision améliore l’efficacité des processus de révision et de résolution du code, en simplifiant les flux de travail de développement et en permettant aux développeurs de résoudre les problèmes directement dans le contexte de leur base de code.\n\nCode scanning affiche également des alertes dans les résultats des vérifications de la demande de tirage lorsque toutes les lignes de code identifiées par l’alerte existent dans le différentiel de la demande de tirage.\n\nPour être affichée dans une vérification de demande de tirage, une alerte doit remplir toutes les conditions suivantes :\n\n* Toutes les lignes de code identifiées par l’alerte existent dans le différentiel de la demande de tirage, y compris la première ligne de l’alerte.\n* L’alerte doit exister dans les lignes de code ajoutées ou modifiées dans la demande de tirage, et non dans les lignes qui ont été supprimées.\n\nL’objet `physicalLocation` d’un fichier SARIF soumis identifie les lignes de code d’une alerte. Pour plus d’informations, consultez l’objet [`physicalLocation`](#physicallocation-object).\n\n### Emplacement racine des fichiers sources\n\nL’Code scanning interprète les résultats signalés avec des chemins relatifs comme relatifs à la racine du dépôt analysé. Si un résultat contient un URI absolu, l’URI est converti en URI relatif. L’URI relatif peut ensuite être mis en correspondance avec un fichier commité dans le dépôt.\n\nVous pouvez fournir la racine source pour la conversion de l’URI absolu vers l’URI relatif de l’une des manières suivantes.\n\n* [\n `checkout_path` L’entrée ](https://github.com/github/codeql-action/blob/c2c0a2908e95769d01b907f9930050ecb5cf050d/analyze/action.yml#L44-L47) pour l’action `github/codeql-action/analyze`\n* ```\n Le paramètre `checkout_uri` du point de terminaison de l’API de chargement SARIF. Pour plus d’informations, consultez « [AUTOTITLE](/rest/code-scanning/code-scanning#upload-an-analysis-as-sarif-data) ».\n ```\n* [\n `invocations[0].workingDirectory.uri` La propriété ](https://docs.oasis-open.org/sarif/sarif/v2.1.0/csprd01/sarif-v2.1.0-csprd01.html#_Toc9244365) dans l’objet `run` du fichier SARIF\n\nSi vous fournissez une racine source, tout emplacement d’un artefact spécifié à l’aide d’un URI absolu doit utiliser le même schéma d’URI. En cas d’incompatibilité entre le schéma d’URI de la racine source et une ou plusieurs des URI absolus, le chargement est rejeté.\n\nPar exemple, un fichier SARIF est chargé à l’aide de la racine source `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\nLe fichier est correctement chargé car les deux URI absolus utilisent le même schéma d’URI que la racine source.\n\n### Résolution de lien symbolique\n\nSi l’URI relatif d’un résultat est mis en correspondance avec un fichier défini à l’aide d’un lien symbolique, l’analyse de code ne peut pas afficher le résultat. Vous devez alors résoudre tous les fichiers liés par des liens symboliques et signaler les résultats de ces fichiers à l’aide de l’URI résolu.\n\n## Compatibilité des fichiers\n\n\n\nVous pouvez vérifier qu’un fichier SARIF est compatible avec l’code scanning en le testant par rapport aux règles d’ingestion GitHub. Pour plus d’informations, consultez le [validateur SARIF de Microsoft](https://sarifweb.azurewebsites.net/).\n\nPour chaque fichier SARIF compressé au format gzip, le chargement SARIF prend en charge une taille maximale de 10 Mo. Tous les chargements au-delà de cette limite sont rejetés. Si votre fichier SARIF est trop volumineux parce qu’il contient trop de résultats, vous devez mettre à jour la configuration pour vous concentrer sur les résultats des règles ou requêtes les plus importantes. Pour plus d’informations, consultez « [Le fichier de résultats SARIF est trop volumineux](/fr/code-security/how-tos/scan-code-for-vulnerabilities/troubleshooting/troubleshooting-sarif-uploads/file-too-large) ».\n\nL’Code scanning prend en charge le chargement d’un nombre maximal d’entrées pour les objets de données du tableau suivant. Si l’un de ces objets dépasse sa valeur maximale, le fichier SARIF est rejeté. Pour certains objets, il existe également une limite supplémentaire quant au nombre de valeurs qui sont affichées. Dans la mesure du possible, ce sont les valeurs les plus importantes qui sont affichées. Pour tirer le meilleur parti de votre analyse quand elle comprend des données qui dépassent les limites prises en charge, essayez d’optimiser la configuration de l’analyse (par exemple, pour l’outil CodeQL, identifiez et désactivez les requêtes les plus bruyantes). Pour plus d’informations, consultez « [Les résultats SARIF dépassent une ou plusieurs limites](/fr/code-security/how-tos/scan-code-for-vulnerabilities/troubleshooting/troubleshooting-sarif-uploads/results-exceed-limit) ».\n\n
\n\n| **Données SARIF** | **Valeurs maximales** | **Limites pour la troncation des données** |\n| ------------------------------------------- | :-------------------: | ----------------------------------------------------------------------------------------------------- |\n| Exécutions par fichier | 20 | None |\n| Résultats par exécution | 25 000 | Seuls les 5 000 premiers résultats sont inclus, classés par ordre de gravité. |\n| Règles par exécution | 25 000 | None |\n| Extensions d’outil par exécution | 100 | None |\n| Emplacements de flux de thread par résultat | 10 000 | Seuls les 1 000 principaux emplacements de flux de thread sont inclus, classés par ordre de priorité. |\n| Emplacement par résultat | 1 000 | Seuls 100 emplacements sont inclus. |\n| Étiquettes par règle | 20 | Seules 10 étiquettes sont incluses. |\n| Limite d’alerte | 1 000 000 | Aucun(e) |\n\n
\n\nPour plus d’informations sur les autres erreurs, consultez [Résolution des problèmes de téléchargements SARIF](/fr/code-security/how-tos/scan-code-for-vulnerabilities/troubleshooting/troubleshooting-sarif-uploads).\n\n## Propriétés prises en charge\n\nSi vous utilisez un moteur d’analyse de code autre que CodeQL, vous pouvez passer en revue les propriétés SARIF prises en charge pour optimiser l’affichage de vos résultats d’analyse sur GitHub.\n\n> \\[!NOTE]\n> Vous devez fournir une valeur explicite pour toute propriété marquée comme « obligatoire ». La chaîne vide n’est pas prise en charge pour les propriétés obligatoires.\n\nTout fichier de sortie SARIF 2.1.0 valide peut être chargé. Toutefois, l’code scanning n’utilise que les propriétés prises en charge suivantes.\n\n### Objet `sarifLog`\n\n| Nom | Obligatoire | Descriptif |\n| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `$schema` | | URI du schéma JSON SARIF pour la version 2.1.0. Par exemple : `https://json.schemastore.org/sarif-2.1.0.json`. |\n| `version` | | L’Code scanning prend uniquement en charge la version SARIF `2.1.0`. |\n| `runs[]` | | Un fichier SARIF contient un tableau d’une ou plusieurs exécutions. Chaque exécution représente une seule exécution d’un outil d’analyse. Pour plus d’informations sur un `run`, consultez l’objet [`run`](#run-object). |\n\n### Objet `run`\n\nL’Code scanning utilise l’objet `run` pour filtrer les résultats par outil et fournir des informations sur la source d’un résultat. L’objet `run` contient l’objet de composant d’outil `tool.driver`, qui contient des informations sur l’outil qui a généré les résultats. Chaque `run` ne peut avoir des résultats que pour un seul outil d’analyse.\n\n| Nom | Obligatoire | Descriptif |\n| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `tool.driver` | | Objet `toolComponent` qui décrit l’outil d’analyse. Pour plus d’informations, consultez l’objet [`toolComponent`](#toolcomponent-object). |\n| `tool.extensions[]` | | Tableau d’objets `toolComponent` qui représentent l’ensemble des plug-ins ou extensions utilisés par l’outil pendant l’analyse. Pour plus d’informations, consultez l’objet [`toolComponent`](#toolcomponent-object). |\n| `invocation.workingDirectory.uri` | | Ce champ est utilisé uniquement lorsque `checkout_uri` (API de chargement SARIF uniquement) ou `checkout_path` (GitHub Actions uniquement) ne sont pas fournis. La valeur est utilisée pour convertir les URI absolus utilisés dans les objets [`physicalLocation`](#physicallocation-object) en URI relatifs. Pour plus d’informations, consultez [Spécification de la racine des fichiers sources](#root-location-for-source-files). |\n| `results[]` | | Résultats de l’outil d’analyse. L’Code scanning affiche les résultats sur GitHub. Pour plus d’informations, consultez l’objet [`result`](#result-object). |\n\n### Objet `toolComponent`\n\n| Nom | Obligatoire | Descriptif |\n| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `name` | | Nom de l’outil d’analyse. L’Code scanning affiche le nom sur GitHub pour vous permettre de filtrer les résultats par outil. |\n| `version` | | Version de l’outil d’analyse. L’Code scanning utilise le numéro de version pour suivre quand les résultats peuvent avoir changé en raison d’un changement de version d’outil plutôt que d’un changement dans le code en cours d’analyse. Si le fichier SARIF inclut le champ `semanticVersion`, `version` n’est pas utilisé par l’code scanning. |\n| `semanticVersion` | | Version de l’outil d’analyse, spécifiée par le format de la Gestion sémantique de version 2.0. L’Code scanning utilise le numéro de version pour suivre quand les résultats peuvent avoir changé en raison d’un changement de version d’outil plutôt que d’un changement dans le code en cours d’analyse. Si le fichier SARIF inclut le champ `semanticVersion`, `version` n’est pas utilisé par l’code scanning. Pour plus d’informations, consultez [Semantic Versioning 2.0.0](https://semver.org/) dans la documentation sur Semantic Versioning. |\n| `rules[]` | | Tableau d’objets `reportingDescriptor` qui représentent des règles. L’outil d’analyse utilise des règles pour rechercher les problèmes dans le code en cours d’analyse. Pour plus d’informations, consultez l’objet [`reportingDescriptor`](#reportingdescriptor-object). |\n\n### Objet `reportingDescriptor`\n\nC’est là que vous stockez les détails des règles exécutées pendant l’analyse. Les informations contenues dans ces objets doivent changer rarement, généralement lorsque vous mettez à jour l’outil. Pour plus d’informations, consultez [Règles et résultats](#rules-and-results) ci-dessus.\n\n| Nom | Obligatoire | Descriptif |\n| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `id` | | Identificateur unique de la règle. L’`id` est référencé à partir d’autres parties du fichier SARIF et peut être utilisé par l’code scanning pour afficher des URL sur GitHub. |\n| `name` | | Le nom de la règle. L’Code scanning affiche le nom pour permettre le filtrage des résultats par règle sur GitHub. Limitées à 255 caractères. |\n| `shortDescription.text` | | Description concise de la règle. L’Code scanning affiche la petite description sur GitHub en regard des résultats associés. Limitée à 1 024 caractères. |\n| `fullDescription.text` | | Description de la règle. L’Code scanning affiche la description complète sur GitHub en regard des résultats associés. Limitée à 1 024 caractères. |\n| `defaultConfiguration.level` | | Niveau de gravité par défaut de la règle. L’Code scanning utilise des niveaux de gravité pour vous aider à comprendre dans quelle mesure le résultat est critique pour une règle donnée. Par défaut, la valeur `defaultConfiguration.level` est définie sur `warning`. Vous pouvez toutefois remplacer le niveau par défaut d’une règle en définissant l’attribut `level` dans l’objet `result` associé au résultat. Pour plus d’informations, reportez-vous à la documentation sur l’objet [`result`](#result-object). Les valeurs valides pour `defaultConfiguration.level` sont : `note`, `warning` et `error`. |\n| `help.text` | | Documentation de la règle au format texte. L’Code scanning affiche cette documentation d’aide en regard des résultats associés. |\n| `help.markdown` | | (Recommandé) Documentation de la règle au format Markdown. L’Code scanning affiche cette documentation d’aide en regard des résultats associés. Quand la documentation `help.markdown` est disponible, elle s’affiche à la place de la documentation `help.text`. |\n| `properties.tags[]` | | Tableau de chaînes. L’Code scanning utilise `tags` pour vous permettre de filtrer les résultats sur GitHub. Par exemple, il est possible de filtrer tous les résultats qui ont l’étiquette `security`. |\n| `properties.precision` | | (Recommandé) Une chaîne qui indique la fréquence à laquelle les résultats indiqués par cette règle sont vrais. Par exemple, si vous savez qu’une règle a un taux de faux positifs élevé, la précision doit être `low`. L’Code scanning classe les résultats par précision sur GitHub, en affichant en premier les résultats ayant les `level` et `precision` les plus élevés. Peut avoir l’une des valeurs suivantes : `very-high`, `high`, `medium` ou `low`. |\n| `properties.problem.severity` | | (Recommandé) Une chaîne qui indique le niveau de gravité des alertes générées par une requête autre qu’une requête de sécurité. Avec la propriété `properties.precision`, cette chaîne détermine si les résultats sont affichés par défaut sur GitHub de telle sorte que les résultats ayant les `problem.severity` et `precision` les plus élevés soient affichés en premier. Il peut s’agir de l’une des valeurs suivantes : `error`, `warning` ou `recommendation`. |\n| `properties.security-severity` | | (Recommandé uniquement pour les règles de sécurité) Si vous renseignez une valeur pour ce champ, les résultats de la règle seront traités comme des résultats de sécurité. Une chaîne représentant un score indiquant le niveau de gravité, avec une valeur supérieure à 0,0 et allant jusqu’à 10,0, pour les requêtes de sécurité (`@tags` inclut `security`). Avec la propriété `properties.precision`, cette chaîne détermine si les résultats sont affichés par défaut sur GitHub de telle sorte que les résultats ayant les `security-severity` et `precision` les plus élevés soient affichés en premier. Code scanning traduit les scores numériques comme suit : au‑dessus de 9,0, c’est `critical`, de 7,0 à 8,9, c’est `high`, de 4,0 à 6,9, c’est `medium` et de 0,1 à 3,9, c’est `low`. Une valeur de 0,0 ou toute autre valeur en dehors de la plage donnée est considérée comme n’ayant aucune gravité en matière de sécurité. |\n\n### Objet `result`\n\nChaque objet `result` contient les détails d’une alerte dans le codebase. Dans l’objet `results`, vous pouvez référencer la règle qui a détecté l’alerte. Pour plus d’informations, consultez [Règles et résultats](#rules-and-results) ci-dessus.\n\n| Nom | Obligatoire | Descriptif |\n| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `ruleId` | | Identificateur unique de la règle (`reportingDescriptor.id`). Pour plus d’informations, consultez l’objet [`reportingDescriptor`](#reportingdescriptor-object). L’Code scanning utilise l’identificateur de la règle pour filtrer les résultats par règle sur GitHub. |\n| `ruleIndex` | | Index de la règle associée (objet `reportingDescriptor`) dans le tableau `rules` de composants d’outil. Pour plus d’informations, consultez l’objet [`run`](#run-object). La plage autorisée pour cette propriété est comprise entre 0 et 2^63 - 1. |\n| `rule` | | Référence utilisée pour localiser la règle (descripteur de création de rapports) pour ce résultat. Pour plus d’informations, consultez l’objet [`reportingDescriptor`](#reportingdescriptor-object). |\n| `level` | | Gravité du résultat. Ce niveau remplace la gravité par défaut définie par la règle. L’Code scanning utilise le niveau pour filtrer les résultats par gravité sur GitHub. |\n| `message.text` | | Message qui décrit le résultat. L’Code scanning affiche le texte du message comme titre du résultat. Seule la première phrase du message s’affiche quand l’espace visible est limité. |\n| `locations[]` | | Ensemble d’emplacements où le résultat a été détecté, dans la limite de 10. Un seul emplacement doit être inclus, sauf si le problème ne peut être corrigé qu’en effectuant une modification à chaque emplacement spécifié. |\n\n```\n **Remarque :** au moins un emplacement est requis pour que l’code scanning affiche un résultat. L’Code scanning utilise cette propriété pour décider quel fichier annoter avec le résultat. Seule la première valeur de ce tableau est utilisée. Toutes les autres valeurs sont ignorées.\n```\n\n\\| `partialFingerprints`| | Ensemble de chaînes utilisées pour suivre l’identité unique du résultat. L’Code scanning utilise `partialFingerprints` pour identifier exactement quels résultats sont identiques entre les commits et les branches. L’Code scanning tente d’utiliser `partialFingerprints` s’ils existent. Si vous chargez des fichiers SARIF tiers avec l’`upload-action`, l’action crée des `partialFingerprints` pour vous quand elles ne sont pas incluses dans le fichier SARIF. Pour plus d’informations, consultez [Fourniture de données pour suivre les alertes d’analyse de code entre les exécutions](#data-for-preventing-duplicated-alerts).\n**Remarque :** l’Code scanning utilise uniquement `primaryLocationLineHash`.\n\\| `codeFlows[].threadFlows[].locations[]`| | Tableau d’objets `location` pour un objet `threadFlow`, qui décrit la progression d’un programme via un thread d’exécution. Un objet `codeFlow` décrit un modèle d’exécution de code utilisé pour détecter un résultat. Si des flux de code sont fournis, l’code scanning les développe sur GitHub pour le résultat approprié. Pour plus d’informations, consultez l’objet [`location`](#location-object).\n\\| `relatedLocations[]`| | Ensemble d’emplacements pertinents pour ce résultat. L’Code scanning établit un lien avec les emplacements associés quand ils sont incorporés dans le message de résultat. Pour plus d’informations, consultez l’objet [`location`](#location-object).\n\n### Objet `location`\n\nEmplacement dans un artefact de programmation, tel qu’un fichier dans le dépôt ou un fichier qui a été produit lors d’une génération.\n\n| Nom | Obligatoire | Descriptif |\n| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `location.id` | | Identificateur unique qui distingue cet emplacement de tous les autres emplacements au sein d’un objet de résultat unique. La plage autorisée pour cette propriété est comprise entre 0 et 2^63 - 1. |\n| `location.physicalLocation` | | Identifie l’artefact et la région. Pour plus d’informations, consultez [`physicalLocation`](#physicallocation-object). |\n| `location.message.text` | | Message correspondant à l’emplacement. |\n\n### Objet `physicalLocation`\n\n| Nom | Obligatoire | Descriptif |\n| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `artifactLocation.uri` | | URI indiquant l’emplacement d’un artefact, généralement un fichier dans le dépôt ou produit lors une génération. Pour obtenir les meilleurs résultats, nous recommandons qu’il s’agit d’un chemin relatif à partir de la racine du référentiel GitHub analysé. Par exemple : `src/main.js`. Pour plus d’informations sur les URI d’artefact, consultez [Spécification de la racine des fichiers sources](#root-location-for-source-files). |\n| `region.startLine` | | Numéro de ligne du premier caractère de la région. |\n| `region.startColumn` | | Numéro de colonne du premier caractère de la région. |\n| `region.endLine` | | Numéro de ligne du dernier caractère de la région. |\n| `region.endColumn` | | Numéro de colonne du caractère qui suit la fin de la région. |\n\n### Objet `runAutomationDetails`\n\nL’objet `runAutomationDetails` contient des informations qui spécifient l’identité d’une exécution.\n\n| Nom | Obligatoire | Descriptif |\n| ---- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `id` | | Chaîne qui identifie la catégorie de l’analyse et l’ID d’exécution. Utilisez cette option si vous souhaitez charger plusieurs fichiers SARIF pour les mêmes outil et commit, mais pour différents langages ou différentes parties du code. |\n\nL’utilisation de l’objet `runAutomationDetails` est facultative.\n\nLe champ `id` peut inclure une catégorie d’analyse et un ID d’exécution. Nous n’utilisons pas la partie d’ID d’exécution du champ `id`, mais nous la stockons.\n\nUtilisez la catégorie pour distinguer plusieurs analyses pour le même outil ou le même commit, mais effectuées dans différents langages ou différentes parties du code. Utilisez l’ID d’exécution pour identifier l’exécution spécifique de l’analyse, telle que la date d’exécution de l’analyse.\n\n```\n `id` est interprété comme `category/run-id`. Si `id` ne contient aucune barre oblique (`/`), la chaîne entière est le `run_id` et la `category` est vide. Sinon, `category` est tout ce qui se trouve dans la chaîne jusqu’à la dernière barre oblique, tandis que `run_id` est tout ce qui se trouve après.\n```\n\n| `id` | catégorie | `run_id` |\n| ---------------------------- | ----------------- | ---------------------- |\n| my-analysis/tool1/2022-01-02 | my-analysis/tool1 | 02-01-2022 |\n| my-analysis/tool1/ | my-analysis/tool1 | Aucun |\n| my-analysis pour tool1 | Aucun | my-analysis pour tool1 |\n\n* L’exécution dont l’`id` est « my-analysis/tool1/2021-02-01 » appartient à la catégorie « my-analysis/tool1 ».\n* L’exécution dont l’`id` est « my-analysis/tool1/ » appartient à la catégorie « my-analysis/tool1 », mais n’est pas distinguée des autres exécutions de cette catégorie.\n* L’exécution dont l’`id` est « my-analysis for tool1 » a un identificateur unique, mais il est impossible de déduire si elle appartient à telle ou telle catégorie.\n\nPour plus d’informations sur l’objet `runAutomationDetails` et le champ `id`, consultez [l’objet runAutomationDetails](https://docs.oasis-open.org/sarif/sarif/v2.1.0/cs01/sarif-v2.1.0-cs01.html#_Toc16012479) dans la documentation OASIS.\n\nNotez que le reste des champs pris en charge est ignoré.\n\n## Exemples de fichiers de sortie SARIF\n\nCes exemples de fichiers de sortie SARIF affichent des propriétés prises en charge et des exemples de valeurs.\n\n### Exemple avec les propriétés minimales requises\n\nCe fichier de sortie SARIF contient des exemples de valeurs pour illustrer les propriétés qui sont indispensables aux résultats d’code scanning. Si vous supprimez des propriétés, que vous omettez des valeurs ou que vous utilisez une chaîne vide, ces données ne s’affichent pas correctement ou ne sont pas synchronisées sur 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### Recommandations relatives aux URI pour les producteurs SARIF\n\nCe fichier de sortie SARIF contient des exemples de valeurs pour le champ `originalUriBaseIds`, affichant les propriétés minimales requises qu’un producteur SARIF doit inclure lors de l’utilisation de références d’URI relatives.\n\n> \\[!NOTE]\n> Bien que cette propriété ne soit pas requise par GitHub pour que les résultats de l’code scanning soient affichés correctement, elle est nécessaire pour produire une sortie SARIF valide lors de l’utilisation de références URI relatives.\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### Exemple montrant toutes les propriétés SARIF prises en charge\n\nCe fichier de sortie SARIF contient des exemples de valeurs pour illustrer toutes les propriétés SARIF prises en charge pour l’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```"}