Prise en charge de SARIF pour l’analyse du code

À propos de la prise en charge de SARIF

SARIF (Static Analysis Results Interchange Format) est une norme OASIS qui définit un format de fichier de sortie. La norme SARIF est utilisée pour simplifier la façon dont les outils d’analyse statique partagent leurs résultats. L’Code scanning prend en charge une partie du schéma JSON SARIF 2.1.0.

Pour charger un fichier SARIF à partir d’un moteur d’analyse de code statique tiers, vous devez vous assurer que les fichiers chargés utilisent la version SARIF 2.1.0. GitHub analyse le fichier SARIF et affiche des alertes en utilisant les résultats dans votre dépôt dans le cadre de l’expérience d’code scanning. Pour plus d’informations, consultez « Chargement d’un fichier SARIF sur GitHub ». Pour plus d’informations sur le schéma JSON SARIF 2.1.0, consultez sarif-schema-2.1.0.json.

Si 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. Pour plus d’informations, consultez Configuration de la configuration par défaut pour l’analyse du code ou Utilisation de l'analyse du code avec votre système CI existant.

GitHub utilise les propriétés dans le fichier SARIF pour afficher les alertes. Par exemple, les propriétés shortDescription et fullDescription apparaissent en haut d’une alerte d’code scanning. La propriété location permet à GitHub d’afficher les annotations dans votre fichier de code. Pour plus d’informations, consultez « À propos des alertes d’analyse du code ».

Si vous débutez avec SARIF et que vous souhaitez en savoir plus, consultez le dépôt SARIF tutorials de Microsoft.

Fourniture de données pour suivre les alertes d’code scanning entre les exécutions

À 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.

Signalement de chemins de fichiers cohérents

Le 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.

Inclusion de données pour la génération d’empreintes digitales

GitHub 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 dans la documentation OASIS.

Les 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.

Si 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 : https://github.com/github/codeql-action/blob/main/src/fingerprints.ts. Pour plus d’informations sur l’API, consultez Points de terminaison d’API REST pour l’analyse de codes.

Présentation des règles et des résultats

Les 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.

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.
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.

Lorsque 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.

Spécification de l’emplacement des fichiers sources

La spécification de l'emplacement du fichier source 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 la résolution le problème de manière ciblée.

Cette précision améliore l’efficacité des processus de révision du code et de résolution et simplifie les flux de travail de développement en permettant aux développeurs de résoudre les problèmes directement dans le contexte de leur codebase.

Code scanning affiche également des alertes dans les résultats de vérification des demandes de tirage (pull request) lorsque toutes les lignes de code identifiées par l’alerte existent dans un diff de demande de tirage.

Pour l’affichage dans une vérification de demande de tirage (pull request), une alerte doit remplir toutes les conditions suivantes :

Toutes les lignes de code identifiées par l’alerte existent dans un diff de demande de tirage (pull request), y compris la première ligne de l’alerte.
L’alerte doit exister dans les lignes de code ajoutées ou modifiées dans la demande de tirage (pull request), et non dans les lignes qui ont été supprimées.

L’objet physicalLocation d’un fichier SARIF soumis identifie les lignes de code d’une alerte. Pour plus d’informations, consultez physicalLocationl’objet .

Spécification de la racine des fichiers sources

L’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.

Vous pouvez fournir la racine source pour la conversion de l’URI absolu vers l’URI relatif de l’une des manières suivantes.

Entrée checkout_path dans l’action github/codeql-action/analyze
Paramètre checkout_uri du point de terminaison de l’API de chargement SARIF. Pour plus d’informations, consultez « Points de terminaison d’API REST pour l’analyse de codes ».
Propriété invocations[0].workingDirectory.uri dans l’objet run dans le fichier SARIF

Si 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é.

Par exemple, un fichier SARIF est chargé à l’aide de la racine source 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

Le fichier est correctement chargé car les deux URI absolus utilisent le même schéma d’URI que la racine source.

Résolution des liens symboliques avant la génération des résultats SARIF

Si l’URI relatif d’un résultat est mis en correspondance avec un fichier défini à l’aide d’un lien symbolique, l’analyse du code ne peut pas afficher le résultat. Vous devez alors résoudre les fichiers liens symboliques et signaler les résultats de ces fichiers à l’aide de l’URI résolu.

Validation de votre fichier SARIF

Vous 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.

Pour 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 ».

L’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 y a également une limite supplémentaire au nombre de valeurs qui seront 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 ».

Données SARIF	Valeurs maximales	Limites pour la troncation des données
Exécutions par fichier	20	None
Résultats par exécution	25 000	Seuls les 5 000 premiers résultats sont inclus, classés par ordre de gravité.
Règles par exécution	25 000	None
Extensions d’outil par exécution	100	None
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é.
Emplacement par résultat	1 000	Seuls 100 emplacements sont inclus.
Étiquettes par règle	20	Seules 10 étiquettes sont incluses.
Limite d’alerte	1 000 000	Aucun(e)

Pour plus d’informations sur les autres erreurs, consultez Résolution des problèmes de chargements SARIF

Chargement de plusieurs fichiers SARIF pour une validation

Vous pouvez charger plusieurs fichiers SARIF pour le même commit et afficher les données de chaque fichier en tant que résultats d’code scanning. Quand vous chargez plusieurs fichiers SARIF pour un commit, vous devez indiquer une « catégorie » pour chaque analyse. La façon de spécifier une catégorie varie selon la méthode d’analyse :

Si vous utilisez l’CodeQL CLI directement, transmettez l’argument --sarif-category à la commande codeql database analyze quand vous générez des fichiers SARIF. Pour plus d’informations, consultez « À propos de CodeQL CLI ».
Si vous utilisez GitHub Actions avec codeql-action/analyze, la catégorie est définie automatiquement à partir du nom du workflow et de toutes les variables de matrice (généralement, language). Vous pouvez à la place spécifier une entrée category pour l’action, ce qui est utile quand vous analysez différentes sections d’un mono-référentiel dans un seul workflow.
Si vous utilisez GitHub Actions pour charger des résultats à partir d’autres outils d’analyse statique, vous devez spécifier une entrée category si vous chargez plusieurs fichiers de résultats pour le même outil dans un workflow. Pour plus d’informations, consultez « Chargement d’un fichier SARIF sur GitHub ».
Si vous n’utilisez pas l’une de ces approches, vous devez spécifier un runAutomationDetails.id unique dans chaque fichier SARIF à charger. Pour plus d’informations sur cette propriété, consultez runAutomationDetailsl’objet .

Si vous chargez un deuxième fichier SARIF pour un commit avec la même catégorie et à partir du même outil, les résultats précédents sont remplacés. Toutefois, si vous essayez de charger plusieurs fichiers SARIF pour le même outil et la même catégorie dans une seule exécution de workflow GitHub Actions, la configuration incorrecte est détectée et l’exécution échoue.

Propriétés du fichier de sortie SARIF prises en charge

Si 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.

Note

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.

Tout 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.

l'objet `sarifLog`

Nom	Obligatoire	Description
`$schema`		URI du schéma JSON SARIF pour la version 2.1.0. Par exemple : `https://json.schemastore.org/sarif-2.1.0.json`.
`version`		L’Code scanning prend uniquement en charge la version SARIF `2.1.0`.
`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 Objet `run`.

l'objet `run`

L’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.

Nom	Obligatoire	Description
`tool.driver`		Objet `toolComponent` qui décrit l’outil d’analyse. Pour plus d’informations, consultez l’objet `toolComponent`.
`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`.
`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 des objets`physicalLocation` en URI relatifs. Pour plus d’informations, consultez Spécification de la racine des fichiers sources.
`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`.

l'objet `toolComponent`

Nom	Obligatoire	Description
`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.
`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.
`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 Gestion sémantique de version 2.0.0 dans la documentation sur la Gestion sémantique de version.
`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`.

l'objet `reportingDescriptor`

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. Pour plus d’informations, consultez Présentation des règles et des résultats ci-dessus.

Nom	Obligatoire	Description
`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.
`name`		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.
`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.
`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.
`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. La valeur `defaultConfiguration.level` est définie sur `warning`, par défaut. 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, consultez la `result`documentation de l’objet. Les valeurs valides pour `defaultConfiguration.level` sont : `note`, `warning` et `error`.
`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.
`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`.
`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`.
`properties.precision`		(Recommandé) 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`.
`properties.problem.severity`		(Recommandé) 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. Peut avoir l’une des valeurs suivantes : `error`, `warning` ou `recommendation`.
`properties.security-severity`		(Recommandé uniquement pour les règles de sécurité) Si vous incluez une valeur pour ce champ, les résultats de la règle sont traités comme des résultats de sécurité. Une chaîne représentant un score qui indique le niveau de gravité, une valeur supérieure à 0,0 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 : `critical` au-dessus de 9,0, `high` de 7,0 à 8,9, `medium` de 4,0 à 6,9 et `low` de 0,1 à 3,9. 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é de sécurité.

l'objet `result`

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. Pour plus d’informations, consultez Présentation des règles et des résultats ci-dessus.

Vous pouvez vérifier que les propriétés SARIF ont la taille prise en charge pour le chargement et que le fichier est compatible avec l’analyse du code. Pour plus d’informations, consultez « Prise en charge de SARIF pour l’analyse du code ».

Nom	Obligatoire	Description
`ruleId`		Identificateur unique de la règle (`reportingDescriptor.id`). Pour plus d’informations, consultez l’objet `reportingDescriptor`. L’Code scanning utilise l’identificateur de la règle pour filtrer les résultats par règle sur GitHub.
`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`. La plage autorisée pour cette propriété est comprise entre 0 et 2^63 - 1.
`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`.
`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.
`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é.
`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é. 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.
`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. Remarque : L’Code scanning utilise uniquement le `primaryLocationLineHash`.
`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`.
`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`.

l'objet `location`

Emplacement 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.

Nom	Obligatoire	Description
`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.
`location.physicalLocation`		Identifie l’artefact et la région. Pour plus d’informations, consultez l’objet `physicalLocation`.
`location.message.text`		Message correspondant à l’emplacement.

l'objet `physicalLocation`

Nom	Obligatoire	Description
`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 des résultats optimaux, nous recommandons qu’un chemin relatif à partir de la racine du dépôt GitHub soit analysé. Par exemple : `src/main.js`. Pour plus d’informations sur les URI d’artefact, consultez Spécification de la racine des fichiers sources.
`region.startLine`		Numéro de ligne du premier caractère de la région.
`region.startColumn`		Numéro de colonne du premier caractère de la région.
`region.endLine`		Numéro de ligne du dernier caractère de la région.
`region.endColumn`		Numéro de colonne du caractère qui suit la fin de la région.

l'objet `runAutomationDetails`

L’objet runAutomationDetails contient des informations qui spécifient l’identité d’une exécution.

Nom	Obligatoire	Description
`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.

L’utilisation de l’objet runAutomationDetails est facultative.

Le 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.

Utilisez 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.

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.

`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 pour tool1	None	my-analysis pour tool1

L’exécution dont l’id est « my-analysis/tool1/2021-02-01 » appartient à la catégorie « my-analysis/tool1 ».
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.
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.

Pour plus d’informations sur l’objet runAutomationDetails et le champ id, consultez l’objet runAutomationDetails dans la documentation OASIS.

Notez que le reste des champs pris en charge est ignoré.

Exemples de fichiers de sortie SARIF

Ces exemples de fichiers de sortie SARIF affichent des propriétés prises en charge et des exemples de valeurs.

Exemple avec les propriétés minimales requises

Ce 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.

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

Conseils relatifs sur l’URI pour les producteurs SARIF

Ce 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.