Carte de l’application : fonctionnalités d’IA GitHub pour la sécurité et la qualité

Qu’est-ce qu’une carte de demande ?

GitHub’s application and platform cards are intended to help you understand how our AI technology works, the choices application owners can make that influence application performance and behavior, and the importance of considering the whole application, including the technology, the people, and the environment. Application cards are created for AI applications and platform cards are created for AI platform services. These resources can support the development or deployment of your own applications and can be shared with users or stakeholders impacted by them.

As part of its commitment to responsible AI, GitHub adheres to Microsoft's six core principles: fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability. These principles are embedded in the Responsible AI Standard, which guides teams in designing, building, and testing AI applications. Application and Platform Cards play a key role in operationalizing these principles by offering transparency around capabilities, intended uses, and limitations. For further insight, readers are encouraged to explore Microsoft’s Responsible AI Transparency Report and Termes GitHub.

1. Vue d’ensemble

la plateforme de sécurité et de qualité de GitHub comprend plusieurs fonctionnalités optimisées par l'IA qui aident les développeurs à trouver et corriger les vulnérabilités de sécurité, à détecter les secrets divulguées et à améliorer la qualité du code. Cette carte d’application couvre les expériences suivantes :

Copilot Autofix pour l’analyse de code : génère automatiquement des suggestions de correction pour les alertes CodeQL sur les pull requests et la branche par défaut.
Détection de secrets génériques : utilise un modèle pour identifier les secrets non structurés dans le code source que la correspondance de modèle déterministe ne peut pas trouver.
Générateur de regex de modèle personnalisé : utilise l’IA pour générer des expressions régulières pour les modèles d’analyse de secrets personnalisés à partir de descriptions de langage naturel.
GitHub Code Quality : détecte les problèmes de qualité du code et propose des suggestions de correction générées par un LLM sur les pull requests et la branche par défaut.

Copilot Autofix est une extension de l’analyse de code qui fournit aux utilisateurs des recommandations ciblées pour les aider à corriger les alertes issues de l’analyse de code, afin d’éviter l’introduction de nouvelles failles de sécurité. Les correctifs potentiels sont générés automatiquement par des modèles de langage volumineux (LLMs) à l’aide de données provenant de la base de code et de l’analyse du code. Copilot Autofix est disponible pour l'analyse CodeQL et ne nécessite pas d'abonnement GitHub Copilot.

Les utilisateurs de l’analyse de code peuvent déjà voir les alertes de sécurité sur leurs pull requests. Toutefois, les développeurs ont souvent peu de formation sur le codage sécurisé, de sorte que la résolution de ces alertes nécessite un effort considérable. Copilot Autofix abaisse les barrières à l’entrée en combinant des informations sur les bonnes pratiques avec des détails sur la base de code et sur l’alerte afin de proposer un correctif potentiel. Au lieu de commencer par une recherche d’informations sur la vulnérabilité, le développeur commence par une suggestion de code illustrant une solution potentielle pour son codebase. Le développeur évalue le correctif potentiel afin de déterminer s’il s’agit de la meilleure solution pour son codebase et de s’assurer qu’il conserve le comportement attendu.

La détection générique des secrets de l'analyse des secrets est une extension basée sur l'IA qui identifie les secrets non structurés dans le code source ou sur d'autres surfaces GitHub et génère une alerte. Les utilisateurs de GitHub Secret Protection et de GitHub Advanced Security peuvent déjà recevoir des alertes d’analyse des secrets pour les motifs partenaires ou personnalisés détectés dans leur code source, mais les secrets non structurés ne sont pas faciles à détecter. L’analyse des secrets utilise des modèles pour identifier ces secrets. Lorsqu’une recherche est détectée, une alerte s’affiche dans la liste « Générique » des alertes d’analyse des secrets (sous l’onglet Sécurité du référentiel, de l’organisation ou de l’entreprise), afin que les responsables de la maintenance et de sécurité puissent examiner l’alerte et, le cas échéant, supprimer les informations d’identification ou implémenter un correctif. La détection de secrets génériques ne nécessite pas d’abonnement GitHub Copilot.

Le générateur d'expressions régulières pour les modèles personnalisés de l'analyse des secrets permet de définir des modèles personnalisés sans connaissance des expressions régulières. Les utilisateurs entrent une description du langage naturel de ce qu’ils veulent détecter, ainsi que des exemples facultatifs de chaînes, et le générateur produit jusqu’à trois expressions régulières candidates. Ces modèles peuvent ensuite être validés via le mécanisme à sec avant d’être déployés en tant que modèles personnalisés. Le générateur d’expressions régulières ne nécessite pas d’abonnement GitHub Copilot.

GitHub Code Quality aide les utilisateurs à améliorer la fiabilité du code, la maintenabilité et l’état de santé global du projet en mettant en évidence des retours exploitables et en proposant des correctifs automatiques pour les problèmes détectés dans les pull requests et sur la branche par défaut. Lorsque la qualité du code est activée, deux types d’exécution d’analyse : les requêtes de qualité CodeQL identifient les problèmes liés à la maintenance, à la fiabilité ou au style de code, et l’analyse basée sur LLM fournit des insights supplémentaires au-delà de ce que les moteurs déterministes peuvent trouver. Lorsqu’un problème de qualité est détecté, Copilot Autofix propose un correctif approprié. Sur les pull requests, les résultats s’affichent sous forme de commentaires laissés par le bot github-code-quality. Sur la branche par défaut, les résultats générés par des LLM sont affichés dans le tableau de bord Résultats de l’IA dans l’onglet Sécurité et qualité.

La langue principale prise en charge pour les fonctionnalités d’IA de sécurité du code GitHub est l’anglais.

2. Termes clés

La liste suivante fournit un glossaire des termes clés liés aux fonctionnalités d’IA de sécurité du code GitHub :

CodeQL : moteur d'analyse sémantique de GitHub pour identifier les vulnérabilités de sécurité dans le code source.
Copilot Autofix : fonctionnalité de GitHub alimentée par un LLM, qui génère automatiquement des suggestions de correctif pour les alertes de l’analyse de code. Copilot Autofix est disponible pour l'analyse CodeQL et ne nécessite pas d'abonnement GitHub Copilot.
Modèle de langage volumineux (LLM) : type de réseau neuronal formé sur un grand corps de données de texte pouvant générer, analyser et transformer le langage naturel et le code. Copilot Autofix utilise un ou plusieurs grands modèles de langage (LLM) pour traiter les alertes d’analyse de code et générer des suggestions de correction.
Détection par IA pour l’analyse des secrets : fonctionnalités basées sur l’IA qui étendent l’analyse des secrets, y compris la détection de secrets génériques. Ne nécessite pas d’abonnement GitHub Copilot.
Détection de secrets génériques : identification ia de secrets non structurés (tels que les mots de passe) qui ne sont pas couverts par des modèles partenaires ou personnalisés. La détection de secret générique utilise des modèles pour rechercher des chaînes de type mot de passe dans le code source.
Modèle personnalisé : expression régulière définie par l’utilisateur utilisée par l’analyse secrète pour détecter les secrets qui correspondent à un format spécifique. Le générateur d’expressions régulières de modèle personnalisé permet de créer ces modèles à partir de descriptions de langage naturel.
SARIF : Format d’échange des résultats d’analyse statique : le format standard utilisé par CodeQL pour signaler les résultats de l’analyse du code, y compris les emplacements d’alerte et les descriptions.
GitHub Qualité du code : fonctionnalité qui présente les problèmes de qualité du code et offre des correctifs basés sur LLM. La qualité du code combine les requêtes de qualité CodeQL avec l’analyse basée sur LLM pour identifier la maintenance, la fiabilité et les problèmes de style.
Résultats de l’IA : le tableau de bord de l’onglet Sécurité et qualité, dans lequel sont affichés les résultats de qualité du code générés par des LLM pour la branche par défaut.

3. Fonctionnalités clés

Les principales fonctionnalités et capacités présentées ici décrivent ce que les fonctionnalités d’IA de GitHub Code Security sont conçues pour faire et comment elles fonctionnent dans le cadre des tâches prises en charge.

Suggestions de correctifs automatiques pour les alertes de sécurité : Copilot Autofix génère automatiquement des suggestions de modifications de code pour les alertes CodeQL détectées dans les pull requests et sur la branche par défaut. Chaque suggestion inclut à la fois le changement de code proposé et une explication du langage naturel du correctif.
Alert-to-fix translation : Copilot Autofix traduit la description et l’emplacement d’une alerte d’analyse du code en modifications de code applicables susceptibles de résoudre la vulnérabilité de sécurité sous-jacente. Le système utilise les données des alertes CodeQL au format SARIF, les extraits de code environnants et le texte d’aide de la requête pour générer des correctifs pertinents.
Prise en charge multilingue : Copilot Autofix prend en charge la génération de correctifs pour un sous-ensemble de requêtes incluses dans les suites de requêtes CodeQL par défaut et étendues pour la sécurité pour C#, C/C++, Go, Java/Kotlin, Swift, JavaScript/TypeScript, Python, Ruby et Rust. Pour plus d’informations sur ces suites de requêtes, consultez Suites de requêtes CodeQL.

          **Détection des mots de passe basée sur l'IA** : la détection générique des secrets de l'analyse des secrets analyse le contenu des dépôts à l'aide de l'IA pour identifier les secrets non structurés (comme les mots de passe) que les modèles déterministes ne peuvent pas détecter. Les secrets détectés sont exposés sous forme d’alertes dans la liste des alertes d’analyse des secrets sous l’onglet **<svg version="1.1" width="16" height="16" viewBox="0 0 16 16" class="octicon octicon-shield" aria-label="shield" role="img"><path d="M7.467.133a1.748 1.748 0 0 1 1.066 0l5.25 1.68A1.75 1.75 0 0 1 15 3.48V7c0 1.566-.32 3.182-1.303 4.682-.983 1.498-2.585 2.813-5.032 3.855a1.697 1.697 0 0 1-1.33 0c-2.447-1.042-4.049-2.357-5.032-3.855C1.32 10.182 1 8.566 1 7V3.48a1.75 1.75 0 0 1 1.217-1.667Zm.61 1.429a.25.25 0 0 0-.153 0l-5.25 1.68a.25.25 0 0 0-.174.238V7c0 1.358.275 2.666 1.057 3.86.784 1.194 2.121 2.34 4.366 3.297a.196.196 0 0 0 .154 0c2.245-.956 3.582-2.104 4.366-3.298C13.225 9.666 13.5 8.36 13.5 7V3.48a.251.251 0 0 0-.174-.237l-5.25-1.68ZM8.75 4.75v3a.75.75 0 0 1-1.5 0v-3a.75.75 0 0 1 1.5 0ZM9 10.5a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path></svg>Sécurité et sécurité de**.

Génération d’expressions régulières alimentées par l’IA : le générateur d’expressions régulières de l’analyse secrète prend une description en langage naturel du modèle que vous souhaitez détecter, ainsi que des exemples facultatifs de chaînes et produit jusqu’à trois expressions régulières candidates. Chaque résultat inclut une description en langage brut généré par l’IA, et vous pouvez valider des modèles via une exécution sèche avant le déploiement.
Détection des problèmes de qualité du code : GitHub Code Quality exécute des requêtes de qualité CodeQL sur le code modifié dans les pull requests et régulièrement sur l’intégralité de la branche par défaut. Ces requêtes identifient la facilité de maintenance, la fiabilité et les problèmes de style.
Analyse de la qualité du code alimenté par LLM : après chaque envoi (push) vers la branche par défaut, un LLM analyse les fichiers récemment modifiés pour des problèmes de qualité au-delà de ce que les moteurs déterministes peuvent trouver. Les résultats sont affichés dans le tableau de bord des résultats de l’IA .
** Suggestions de correctifs automatiques pour les résultats de qualité** : lorsqu’un problème de qualité est détecté par l’un ou l’autre type d’analyse, Copilot correction automatique génère une suggestion de correctif. Sur les pull requests, le bot github-code-quality publie un commentaire contenant la modification suggérée.

4. Utilisations prévues

GitHub fonctionnalités d’IA de sécurité du code peuvent être utilisées dans plusieurs scénarios dans divers secteurs d’activité. Voici quelques exemples de cas d’usage :

Accélérer la correction des vulnérabilités de sécurité : utilisez Copilot Autofix pour générer rapidement des suggestions de correction pour les alertes CodeQL, réduisant ainsi le temps et le niveau d’expertise nécessaires pour traiter les problèmes de sécurité détectés lors de l’analyse du code.
Reducing the barrier to secure coding : Copilot Autofix aide les développeurs à suivre une formation de codage sécurisé limitée. Au lieu de rechercher des vulnérabilités indépendamment, les développeurs commencent par une suggestion de code qui illustre une solution potentielle pour leur codebase.
Simplifier la révision des pull requests : lorsque l’analyse du code détecte des alertes dans une pull request, Copilot Autofix propose des correctifs directement dans la pull request, aidant les développeurs à résoudre les problèmes de sécurité avant de la fusionner.
Correction des alertes sur la branche par défaut : Copilot Autofix peut également générer des suggestions de correctif pour les alertes existantes sur la branche par défaut, aidant les équipes à réduire leur backlog de constatations de sécurité.
Détecter les mots de passe divulgués dans le code source : utilisez la détection générique des secrets pour rechercher des secrets non structurés dans les dépôts qui n’entrent pas dans le champ de détection des modèles d’analyse des secrets partenaires et personnalisés.
Triage des informations d’identification avec des alertes contextuelles : lorsqu’un mot de passe est détecté, une alerte avec le contexte de détection d’IA s’affiche dans la liste des alertes, ce qui permet aux responsables de la maintenance et de la sécurité de passer en revue la recherche et de prendre des mesures.
Création de modèles d’analyse de secrets personnalisés sans expertise régulière : utilisez le générateur d’expressions régulières pour définir des modèles personnalisés en décrivant ce que vous souhaitez détecter en langage naturel, en supprimant la nécessité d’écrire manuellement des expressions régulières.
Validation des modèles générés avant le déploiement : après avoir généré des expressions régulières, utilisez le mécanisme de série sèche pour tester les modèles dans votre référentiel ou votre organisation avant de les déployer en tant que modèles personnalisés.
Surfacing code quality issues across a repository : Use GitHub Code Quality pour identifier la facilité de maintenance, la fiabilité et les problèmes de style afin que les développeurs et les administrateurs puissent hiérarchiser rapidement les zones de risque.
Accélérer la correction des problèmes de qualité du code : Copilot Autofix suggère des correctifs pour les problèmes de qualité en combinant des informations sur les bonnes pratiques avec des détails de la base de code afin de proposer un correctif potentiel directement dans la pull request ou dans le tableau de bord des problèmes détectés par l’IA.
Fournir des commentaires actionnables sur les demandes de tirage : le github-code-quality bot publie des commentaires avec des correctifs suggérés sur les demandes de tirage, aidant les développeurs à résoudre les problèmes de qualité avant de fusionner.

5. Modèles et données d’entraînement

Copilot Autofix utilise des API internes de GitHub Copilot qui interagissent avec les grands modèles de langage, lesquels génèrent à la fois des correctifs de code suggérés et du texte explicatif pour ces correctifs.

La détection de secrets génériques utilise des modèles pour rechercher des secrets non structurés.

Le générateur d’expressions régulières à partir de motifs personnalisés utilise des LLM et l’API GitHub Copilot pour générer des expressions régulières qui correspondent aux descriptions et aux exemples fournis par l’utilisateur.

L'analyse de GitHub Code Quality basée sur les LLM utilise les modèles de langage de Copilot pour analyser les fichiers récemment modifiés à la recherche de problèmes de qualité. Le composant de requêtes de qualité CodeQL n’utilise pas de LLM. Copilot Autofix pour les résultats de Code Quality utilise le même pipeline de LLM que Copilot Autofix pour le code scanning.

Pour obtenir une comparaison des modèles disponibles pour Copilot, consultez Comparaison des modèles IA. Pour obtenir la liste complète des modèles pris en charge, consultez Modèles IA pris en charge dans GitHub Copilot. Pour plus d’informations sur l’emplacement d’hébergement des modèles, consultez Hébergement de modèles pour GitHub Copilot. Pour en savoir plus sur les données utilisées pour former les modèles de base derrière GitHub sécurité et la qualité, consultez Quelles données ont GitHub Copilot été formées sur ? dans la FAQ GitHub Copilot.

Les données traitées par Copilot Autofix ne sont pas utilisées pour l’entraînement des LLM. L’utilisation de cette fonctionnalité est régie par les conditions générales existantes associées à GitHub Advanced Security. Pour plus d’informations, consultez Conditions GitHub pour les produits et fonctionnalités supplémentaires.

6. Performances

Lorsque Copilot correction automatique est activée pour un référentiel, les alertes d’analyse du code sont traitées via le pipeline suivant :

Input processing : Lorsqu’une alerte d’analyse du code est identifiée, GitHub assemble les données pertinentes dans une invite pour le modèle de langage. Ces données incluent :
- Données d’alerte CodeQL au format SARIF
- Code de la version actuelle de la branche, incluant de courts extraits de code autour de chaque emplacement source, de chaque emplacement de destination et de tout emplacement mentionné dans le message d’alerte ou le chemin de flux
- Les 10 premières lignes de chaque fichier impliqué dans l’un de ces emplacements
- Texte d’aide pour la requête CodeQL qui a identifié le problème
Analyse du modèle de langage : l’invite assemblée est envoyée au modèle de langage, qui analyse le contexte d’alerte, la structure de code et les informations d’aide sur la requête.
Génération de réponse : le modèle génère un correctif potentiel, y compris la modification de code proposée et un texte explicatif décrivant le correctif.
Mise en forme de la sortie : la suggestion est stockée dans le service d’analyse du code et affichée sous forme de suggestion intégrée sur la page de détails de la pull request ou de l’alerte. Aucune interaction utilisateur n’est nécessaire, hormis l’activation de l’analyse du code sur la base de code et la création d’une pull request.

Différences par expérience

La détection des secrets IA traite l’entrée et produit une sortie comme suit :

Traitement d’entrée : l’entrée est limitée au texte (généralement au code) qu’un utilisateur a archivé dans un référentiel. Le système fournit ce texte au modèle ainsi qu’une invite meta demandant au modèle de trouver des secrets non structurés dans l’étendue de l’entrée. L’utilisateur n’interagit pas directement avec le modèle. Plusieurs modèles peuvent être utilisés pour valider une seule recherche.
Analyse du modèle : le modèle analyse les chaînes qui ressemblent à des secrets non structurés comme des mots de passe.
Génération de réponse : le modèle vérifie que les chaînes identifiées incluses dans la réponse existent réellement dans l’entrée.

          **Mise en forme des sorties** : les chaînes détectées sont présentées sous forme d'alertes sur la page des alertes d'analyse des secrets, dans une liste distincte de celle des alertes classiques. Chaque alerte note qu’elle a été détectée par l’IA. Pour plus d’informations sur la façon d’afficher les alertes pour les secrets génériques, consultez [AUTOTITLE](/code-security/secret-scanning/managing-alerts-from-secret-scanning/viewing-alerts).

Le générateur regex de modèle personnalisé traite l’entrée et produit la sortie comme suit :

Traitement d’entrée : les utilisateurs entrent une description de texte en langage naturel du modèle qu’ils souhaitent détecter, ainsi que des exemples facultatifs de chaînes qui doivent être mises en correspondance.
Language model analysis : la description et les exemples sont envoyés au LLM via l’API GitHub Copilot, qui génère des expressions régulières correspondant à l’entrée.
Génération de réponse : le modèle retourne jusqu’à trois expressions régulières candidates. Chaque résultat inclut une description en langage brut généré par l’IA. Certains résultats peuvent être assez similaires, et certains peuvent ne pas correspondre à chaque instance du modèle prévu.
Mise en forme de sortie : les résultats sont affichés dans le formulaire de définition de modèle personnalisé. Lorsque vous cliquez sur Utiliser le résultat, l’expression et tous les exemples sont copiés dans le formulaire de modèle personnalisé principal, où vous pouvez effectuer une exécution sèche pour valider le modèle dans votre référentiel ou votre organisation. Pour plus d’informations, consultez « Définition de modèles personnalisés pour l’analyse des secrets ».

Analyse de la qualité du code GitHub basée sur un LLM traite les entrées et produit les sorties comme suit :

Traitement des entrées : après chaque push vers la branche par défaut, les fichiers récemment modifiés sont combinés avec d’autres informations contextuelles pertinentes pour former un prompt. L’invite est envoyée à un modèle de langage Copilot.
Analyse du modèle de langage : le modèle de langage analyse le code pour la maintenance, la fiabilité et d’autres problèmes de qualité.
Génération de réponse : le modèle génère une réponse qui peut inclure des suggestions de langage naturel et des suggestions de code liées à des lignes spécifiques.
Mise en forme de sortie : les résultats sont affichés dans le tableau de bord des résultats de l’IA sous l’onglet Sécurité et sécurité de. Lorsque la qualité du code fournit une suggestion de code, elle est présentée sous la forme d’une modification suggérée qui peut être appliquée en quelques clics.

Copilot Autofix pour les résultats GitHub Code Quality dans les demandes de tirage :

Traitement des entrées : les problèmes de qualité du code détectés par l’analyse CodeQL sur une pull request sont envoyés au LLM, accompagnés du contexte de code environnant.
Analyse du modèle de langage : LLM analyse la recherche et génère un correctif potentiel.
Génération de réponse : si le LLM peut générer un correctif, il produit une modification de code suggérée.
Mise en forme de sortie : le bot github-code-quality publie un commentaire sur la pull request contenant la modification suggérée. Les utilisateurs peuvent également demander la génération de corrections automatiques pour les résultats de la branche par défaut.

7. Limitations

Comprendre les limites des fonctionnalités d’IA de GitHub Code Security est essentiel pour déterminer si elles sont utilisées dans des conditions sûres et efficaces. Même si nous encourageons les clients à tirer parti de GitHub fonctionnalités IA de sécurité du code dans leurs solutions ou applications innovantes, il est important de noter que GitHub fonctionnalités d'IA de sécurité du code n'a pas été conçue pour chaque scénario possible. Nous encourageons les utilisateurs à faire référence à Termes GitHub ainsi que les considérations suivantes lors du choix d’un cas d’usage :

Non-déterminisme : Copilot Autofix utilise un modèle génératif non déterministe. Même avec la même alerte et le même code, il peut échouer à produire une suggestion viable, ou la suggestion peut varier entre les tentatives.
Complexité et contexte du problème : certaines alertes de sécurité, telles que celles qui nécessitent un flux de données de suivi sur une base de code complexe, multi-fichiers ou qui représentent des failles logiques subtiles, peuvent être difficiles à résoudre pour le modèle.
Taille de fichier : si le code affecté se trouve dans un fichier ou un référentiel très volumineux, le contexte fourni au LLM peut être tronqué. Lorsque le contexte est limité, la fonctionnalité ne tente pas de corriger.
Prise en charge des langages et des frameworks : Bien que Copilot Autofix prenne en charge un nombre croissant de langages et d'alertes CodeQL, il ne prend pas en charge tous les types d'alertes ni tous les langages possibles.
Capacité opérationnelle LLM : la génération de correctifs est soumise à la capacité opérationnelle LLM. Si aucune suggestion n’est disponible ou si un correctif suggéré échoue à des tests internes, aucune suggestion n’est affichée.
Données centrées sur l’anglais : le système utilise principalement des données anglaises, notamment les invites, le code dans les jeux de données d’entraînement du LLM et les cas de test utilisés pour l’évaluation interne. Les suggestions peuvent avoir un taux de réussite inférieur pour le code source et les commentaires dans d’autres langues.
Erreurs de syntaxe : le système peut suggérer des corrections qui ne constituent pas des modifications de code syntaxiquement correctes.
Erreurs d’emplacement : le système peut suggérer des correctifs à des emplacements incorrects. L’acceptation d’un tel correctif sans modifier l’emplacement peut introduire une erreur de syntaxe.
Erreurs sémantiques : le système peut suggérer des correctifs qui sont valides de manière syntactique, mais qui modifient la sémantique du programme. Le système ne comprend pas l’intention du programmeur.
Vulnérabilités de sécurité et correctifs trompeurs : le système peut suggérer des correctifs qui ne parviennent pas à corriger la vulnérabilité sous-jacente ou introduisent de nouvelles vulnérabilités.
Correctifs partiels : le système peut suggérer des correctifs qui ne traitent que partiellement la vulnérabilité de sécurité ou ne conservent que partiellement les fonctionnalités de code prévues.
Modifications des dépendances : les correctifs suggérés peuvent inclure l’ajout ou la mise à jour des dépendances logicielles. Le système ne sait pas quelles versions de dépendance sont prises en charge ou sécurisées, et peut suggérer des dépendances fabriquées publiées sous des noms statistiquement probables. Vérifiez toujours les modifications de dépendance avant la fusion.

Limites spécifiques à la détection de secrets par l’IA

          **Couverture incomplète** : la détection des secrets par IA peut ne pas repérer toutes les informations d'identification enregistrées dans un dépôt. La détection des secrets par l’IA s’améliorera avec le temps. Vous avez la responsabilité ultime d’assurer la sécurité de votre code.

Code de test : la détection des secrets par l’IA peut ne pas détecter les secrets dans le code de test. L’analyse des secrets ignore certaines détections lorsque certaines conditions sont remplies, notamment dans les cas suivants :
- Le chemin d’accès au fichier contient « test », « mock » ou « spec »
- L’extension de fichier est .cs, .go, .java, .js, .kt, .php, .py, .rb, .scala, .swift, ou .ts.

Limitations spécifiques au générateur d’expressions régulières de modèle personnalisé

Couverture incomplète des modèles : les expressions régulières générées peuvent ne pas correspondre à tous les jetons prévus. La qualité des résultats dépend de la spécificité et de la clarté de la description d’entrée.
Résultats non valides ou inappropriés : le générateur peut produire des expressions régulières non valides ou inappropriées pour le cas d’usage prévu.
Modèles structurés uniquement : le générateur d’expressions régulières convient uniquement à la création de modèles pour détecter des formats structurés et prévisibles, et non des correspondances de texte de forme libre.
Performances centrées sur l’anglais : le modèle a été formé principalement sur le contenu en langue anglaise. Les performances peuvent être inférieures lorsque vous fournissez des invites d’entrée en langue naturelle dans des langues autres que l’anglais.
Résultats similaires : certaines expressions régulières retournées peuvent être assez similaires les unes aux autres, ce qui réduit le nombre effectif de modèles candidats distincts.

Limitations spécifiques à la qualité du code GitHub

** Limitations de partage avec Copilot révision de code** : l'analyse basée sur LLM de Code Quality utilise le même modèle de langage sous-jacent et le même moteur d'analyse que Copilot révision de code. Il partage des limitations similaires, notamment la détection incomplète, les faux positifs, la précision de la suggestion de code et les biais potentiels. Pour plus d’informations, consultez « Carte d’application : agents GitHub Copilot ».

          **Correction automatique au mieux des possibilités** : Copilot Autofix pour les résultats GitHub Code Quality fonctionne au mieux des possibilités et ne garantit pas la génération d'une correction pour chaque résultat.

Révision requise : vous devez toujours examiner les suggestions de Correction automatique de Copilot et ajuster les modifications si nécessaire avant de les accepter.

8. Évaluations

Les évaluations des performances et de la sécurité évaluent si les applications IA fonctionnent de manière fiable et sécurisée en examinant des facteurs tels que la base, la pertinence et la cohérence, tout en identifiant les risques liés à la génération de contenu nuisible. Les évaluations suivantes ont été effectuées avec des composants de sécurité déjà en place, qui sont également décrits dans 9. Composants de sécurité et atténuations.

Évaluations des performances et de la qualité

Les fonctionnalités d’IA de sécurité de GitHub sont évaluées sur ses interfaces prises en charge à l’aide d’une combinaison de références standard du secteur (par exemple, SWE-Bench) et de suites d’évaluation développées en interne. Les tâches de benchmark sont sources à partir de référentiels open source publics et de scénarios synthétiques ; aucune requête utilisateur réelle ou code client n’est utilisé sans autorisation. Chaque évaluation inclut plusieurs exécutions indépendantes pour prendre en compte le nondéterminisme dans les sorties du modèle. Les métriques clés incluent le taux de résolution (pourcentage de tâches correctement terminées), l’efficacité des jetons, la latence et la fiabilité des appels d’outil. Les modèles sont réévalués lorsque des mises à jour sont effectuées et surveillées en continu en production via des taux d’erreur, une latence de réponse et des modèles d’utilisation agrégés.

Méthodes d’évaluation des performances et de la qualité

De nouveaux modèles sont soumis à un processus d’évaluation intermédiaire avant le déploiement vers la sécurité du code, la qualité du code et la protection secrète. Les équipes d’intégrateur exécutent des suites de benchmark spécifiques à leur surface, testant le modèle sur des tâches de codage représentatives telles que les correctifs de bogues, la génération de code et la refactorisation multi-fichiers. Les résultats sont examinés par rapport aux bases de référence établies et aux modèles de production existants. Les modèles doivent respecter ou dépasser les performances de référence sur les métriques clés, telles que le taux de résolution, l’efficacité des jetons et la latence, avant de passer à l’étape suivante.

Évaluations des risques et de la sécurité

L’évaluation des risques potentiels associés au contenu généré par l’IA est essentielle pour la protection contre les risques de contenu avec différents degrés de gravité. Cela inclut l’évaluation de la prédisposition d’une application IA à générer du contenu dangereux ou le test des vulnérabilités pour les attaques jailbreak. Pour GitHub, nous effectuons des évaluations de performances, y compris celles qui sont adaptées à des fins de codage provenant de Microsoft Foundry :

Haine et iniquité
Sexuelle
Violence
Auto-préjudice
Matériel protégé
Déverrouillage
Vulnérabilité du code

Données d’évaluation pour la qualité et la sécurité

Nos données d’évaluation sont personnalisées pour évaluer les performances des applications IA dans des domaines clés de sécurité et de qualité, en simulant des scénarios et des risques réels. Nous commençons par identifier les aspects pertinents de l’évaluation des préoccupations en fonction de la recherche multidisciplinaire et des commentaires d’experts. Ces préoccupations sont traduites en objectifs d’évaluation ciblés et guident la formulation des mesures d’évaluation. Pour safety, nous créons des prompts antagonistes pour susciter des réponses indésirables ou des réponses dans des cas limites, qui sont ensuite évalués par des annotateurs assistés par l’IA, entraînés à évaluer la conformité aux normes de GitHub. Pour la qualité, nous élaborons des prompts fondés sur des grilles d’évaluation, adaptés à des scénarios tels que l’évaluation d’applications et d’agents de génération augmentée par récupération (RAG). Les jeux de données sont organisés à partir de diverses sources, notamment des jeux de données synthétiques et publics pour simuler des scénarios utilisateur réels. À l’aide des jeux de données organisés, les deux évaluations subissent un affinement itératif et l’alignement humain pour améliorer l’efficacité et la fiabilité des métriques. Cette méthodologie constitue la base d’évaluations reproductibles et rigoureuses qui reflètent la façon dont les clients utilisent des évaluations pour améliorer l’IA.

Évaluations personnalisées

GitHub utilise un harnais de test automatisé pour surveiller en permanence la qualité des suggestions de correction automatique Copilot. Le banc de test comprend un ensemble de plus de 2 300 alertes provenant d’un ensemble diversifié de dépôts publics où le code mis en évidence a une couverture de test. Les suggestions relatives à ces alertes sont testées pour déterminer la quantité nécessaire pour les modifier avant de les valider dans le codebase. Pour la plupart des alertes de test, les suggestions générées par le LLM peuvent être validées as-is pour corriger l’alerte tout en continuant à réussir tous les tests CI existants.

GitHub teste l'efficacité des suggestions en fusionnant toutes les modifications suggérées, non modifiées, avant d'exécuter l'analyse du code et les tests unitaires du référentiel sur le code résultant :

L’alerte d’analyse du code a-t-elle été corrigée par la suggestion ?
Le correctif a-t-il introduit de nouvelles alertes d’analyse de code ?
Le correctif a-t-il introduit des erreurs de syntaxe que l’analyse du code peut détecter ?
Le correctif a-t-il modifié la sortie de l’un des tests du dépôt ?

En outre, GitHub vérifie de nombreuses suggestions réussies et vérifie qu’elles corrigent l’alerte sans introduire de nouveaux problèmes. Lorsqu’une ou plusieurs de ces vérifications échouent, le tri manuel a montré que, dans de nombreux cas, le correctif proposé était presque correct, mais avait besoin de modifications mineures qu’un utilisateur pouvait identifier et effectuer manuellement.

Le système est également soumis à des tests de résistance afin de détecter d’éventuels effets nocifs (red teaming), et un système de filtrage appliqué au LLM aide à empêcher que des suggestions potentiellement dangereuses ne soient présentées aux utilisateurs.

La détection des secrets par IA a fait l'objet d'exercices de Red Teaming dans le cadre de l'IA responsable, et GitHub continue de surveiller l'efficacité et la sécurité de cette fonctionnalité au fil du temps.

Les résultats du générateur regex de modèle personnalisé sont validés par le biais du mécanisme d’exécution sèche, ce qui permet aux utilisateurs de tester les modèles générés dans leur référentiel ou leur organisation avant de les déployer en tant que modèles personnalisés. Cette étape de validation intégrée permet de s’assurer que les expressions régulières générées s’exécutent comme prévu avant qu’elles ne soient utilisées en production.

L’analyse de GitHub Code Quality, basée sur un LLM, repose sur le même cadre d’évaluation que la revue de code Copilot. Les suggestions Copilot Autofix pour les résultats GitHub Code Quality suivent le même banc d'essai que Copilot Autofix pour l'analyse du code.

9. Composants de sécurité et atténuations

** Human-in-the-loop review** : Copilot Autofix présente toutes les suggestions en tant que modifications de code proposées qui nécessitent une révision et une acceptation explicites des développeurs avant d’être appliquées. Les développeurs doivent évaluer chaque suggestion et s’assurer qu’elle préserve le comportement prévu de la base de code.
Filtrage de contenu : un système de filtrage sur le LLM détecte et empêche les suggestions potentiellement dangereuses d’être affichées aux utilisateurs. Le système est soumis à des tests de résistance par red teaming afin d’identifier les vulnérabilités potentielles.
Test de qualité interne : les suggestions qui échouent aux tests internes ne sont pas affichées aux utilisateurs. La génération de correctifs s’affiche uniquement lorsque le système a une confiance suffisante dans la qualité de la suggestion.
Contrôles d’activation/de désactivation : Copilot Autofix est autorisé par défaut et activé pour chaque référentiel utilisant CodeQL, mais les administrateurs peuvent désactiver Copilot Autofix aux niveaux de l’entreprise, de l’organisation et du référentiel. Pour plus d’informations, consultez « Désactivation de la correction automatique pour les alertes de sécurité d’analyse du code ».
Aucun entraînement sur les données des clients : les données traitées par Copilot Autofix ne sont pas utilisées pour l’entraînement des LLM. L’utilisation de cette fonctionnalité est régie par les conditions générales existantes associées à GitHub Advanced Security.

          **Boucle de rétroaction sur les faux positifs** : lorsque les utilisateurs ferment une alerte de détection générique des secrets et indiquent « Faux positif » comme motif, GitHub utilise le volume de faux positifs pour améliorer le modèle. GitHub n’a pas accès aux littéraux secrets eux-mêmes.

Validation de l’exécution sèche pour les modèles générés : les expressions régulières générées à partir du générateur de regex de modèle personnalisé doivent passer par une étape de validation à exécution sèche avant le déploiement. Les utilisateurs importent explicitement un résultat dans le formulaire de modèle personnalisé et le testent dans leur référentiel ou organisation, ce qui garantit que les modèles s’exécutent comme prévu avant qu’ils ne soient utilisés en production.
Action utilisateur explicite requise : le générateur regex ne déploie pas automatiquement les modèles. Les utilisateurs doivent cliquer sur Utiliser le résultat pour copier une expression générée dans le formulaire de modèle personnalisé, puis enregistrer manuellement et activer le modèle.
Mécanisme de retour d’information sur la qualité du code : les utilisateurs peuvent donner leur avis sur les suggestions de qualité du code à l’aide des boutons pouce levé et pouce baissé sur les commentaires du bot github-code-quality, ce qui aide GitHub à améliorer la qualité des suggestions.
Disponibilité limitée à la préversion : GitHub Code Quality est proposé en préversion, ce qui permet aux organisations d’évaluer la fonctionnalité avant une adoption plus large.

10. Meilleures pratiques pour le déploiement et l’adoption de fonctionnalités d’IA de sécurité du code GitHub

L’IA responsable est un engagement partagé entre GitHub et ses clients. Bien que GitHub crée des applications IA avec sécurité, équité et transparence au cœur, les clients jouent un rôle essentiel dans le déploiement et l’utilisation de ces technologies de manière responsable dans leurs propres contextes. Pour prendre en charge ce partenariat, nous proposons les meilleures pratiques suivantes pour les déploiements et les utilisateurs finaux afin d’aider les clients à implémenter efficacement une IA responsable.

Exercise la prudence et évalue les résultats lors de l’utilisation de fonctionnalités d’IA de sécurité GitHub pour des décisions consécutives ou dans des domaines sensibles : Les décisions consécutives sont celles qui peuvent avoir un impact juridique ou significatif sur l’accès à l’éducation, à l’emploi, aux plateformes financières, aux prestations gouvernementales, aux soins de santé, au logement, à l’assurance, aux plateformes juridiques ou qui pourraient entraîner des dommages physiques, psychologiques ou financiers. Les domaines sensibles, tels que les plateformes financières, les soins de santé et le logement, nécessitent des soins particuliers en raison du risque d’impact disproportionné sur différents groupes de personnes. Lorsque vous utilisez l’IA pour prendre des décisions dans ces domaines, assurez-vous que les parties prenantes concernées peuvent comprendre comment les décisions sont prises, faire appel des décisions et mettre à jour les données d’entrée pertinentes.
Évaluez les considérations légales et réglementaires : Les clients doivent évaluer des obligations légales et réglementaires spécifiques potentielles lors de l’utilisation de toutes les plateformes et solutions IA, ce qui peut ne pas convenir à une utilisation dans chaque secteur ou scénario. En outre, les plateformes ou solutions IA ne sont pas conçues pour et peuvent ne pas être utilisées de manière interdite en termes de service applicables et les codes de conduite pertinents.
Passez toujours en revue les suggestions avant d’accepter : évaluez la modification de code proposée pour vous assurer qu’elle corrige correctement la vulnérabilité de sécurité sans modifier le comportement prévu de votre code. L’utilisation d’une bonne couverture de test permet de vérifier qu’un correctif ne modifie pas le comportement de la base de code.
Vérifiez que les tests CI réussissent : après avoir validé un correctif suggéré ou modifié, vérifiez toujours que les tests d’intégration continue (CI) pour le codebase continuent de réussir et que l’alerte est affichée comme résolue avant de fusionner votre demande de tirage.
Passez en revue attentivement les modifications des dépendances : si un correctif suggéré inclut des modifications apportées aux dépendances, vérifiez que les dépendances ajoutées ou mises à jour sont sécurisées, prises en charge et conservent le comportement prévu de la base de code. Utilisez des solutions de gestion des dépendances, telles que l’API et l’action de révision des dépendances, pour évaluer les modifications. Pour plus d’informations, consultez « Vérification des dépendances ».
Fermez les alertes de faux positifs de manière appropriée : étant donné que la détection de secrets IA peut générer plus de faux positifs que la détection de modèle partenaire, passez en revue la précision de chaque alerte. Lorsque vous vérifiez qu’une alerte est un faux positif, fermez l’alerte et marquez la raison comme « Faux positif » dans l’interface utilisateur GitHub. Ces commentaires permettent d’améliorer le modèle.
Valider les modèles regex générés avec une exécution sèche : lors de l’utilisation du générateur de regex de modèle personnalisé, effectuez toujours une exécution sèche sur des référentiels représentatifs avant de déployer un modèle généré à l’échelle de l’organisation.
Soyez spécifique avec des descriptions : Pour améliorer la qualité des expressions régulières générées, soyez aussi spécifiques que possible avec vos descriptions de langage naturel et incluez divers exemples de chaînes qui représentent les modèles que vous souhaitez détecter.
Passez en revue tous les modèles générés : examinez soigneusement chacune des expressions régulières générées, y compris les descriptions de langage brut générées par l’IA, et envisagez de modifier les résultats pour répondre plus entièrement à vos besoins. Vous restez en fin de compte responsable des modèles personnalisés que vous décidez d’utiliser.
Passez en revue les résultats de la qualité du code avant d’appliquer des correctifs : vérifiez toujours la précision et l’applicabilité des résultats de la qualité du code et des suggestions de correction automatique à votre base de code avant de les accepter.
Fournissez des commentaires sur les suggestions de qualité du code : utilisez les boutons vers le haut et vers le bas sur les github-code-quality commentaires du bot pour améliorer l’outil et résoudre les problèmes ou limitations.
Exercer une surveillance humaine le cas échéant : la surveillance humaine est une protection importante lors de l’interaction avec les applications IA. Bien que nous améliorions continuellement nos applications IA, l’IA peut encore faire des erreurs. Les sorties générées peuvent être inexactes, incomplètes, biaisées, mal alignées ou non pertinentes par rapport à vos objectifs prévus. Cela peut se produire pour diverses raisons, telles que l’ambiguïté dans les entrées ou les limitations des modèles sous-jacents. Par conséquent, les utilisateurs doivent passer en revue les réponses générées par GitHub fonctionnalités IA de sécurité du code et vérifier qu’elles correspondent à leurs attentes et exigences.
Tenez compte du risque de sur-dépendance : La dépendance sur l’IA se produit lorsque les utilisateurs acceptent des sorties IA incorrectes ou incomplètes, principalement parce que les erreurs dans les sorties IA peuvent être difficiles à détecter. Pour l’utilisateur final, une dépendance excessive peut entraîner une baisse de productivité, une perte de confiance, un abandon de l’application, une perte financière, des dommages psychologiques, des dommages physiques, entre autres. (par exemple, un médecin accepte un résultat erroné généré par l’IA).
Soyez prudent lors de la conception de l’IA agentique dans des domaines sensibles : Les utilisateurs doivent faire preuve de prudence lors de la conception et/ou du déploiement d’applications IA agentiques dans des domaines sensibles où les actions de l’agent sont irréversibles ou hautement indirectes. Des précautions supplémentaires doivent également être prises lors de la création de l’IA agentique autonome, comme décrit plus loin dans Termes GitHub.

          **Activez les tests d'intégration continue sur les demandes de tirage** : assurez-vous que des tests d'intégration continue sont en place avant d'activer Copilot Autofix afin de vérifier les exigences fonctionnelles après l'application des corrections par les développeurs.

Utilisez des solutions de gestion des dépendances : activez la vérification des dépendances sur les pull requests pour détecter les modifications des dépendances potentiellement risquées introduites par les suggestions Autofix.
Consulter les métriques de la vue d’ensemble de la sécurité : utilisez le tableau de bord de la vue d’ensemble de la sécurité de votre organisation pour afficher le nombre total de suggestions Copilot Autofix générées pour les pull requests ouvertes et fermées sur une période donnée. Pour plus d’informations, consultez « Affichage des aperçus de sécurité ».

          **Évaluez le volume de faux positifs de la détection des secrets** : évaluez le volume de faux positifs et mettez en place des processus de triage pour la liste des alertes.

Surveiller le volume et la qualité des suggestions de qualité du code : évaluez le volume et la qualité des suggestions de qualité du code et ajustez l’activation selon les besoins de votre organisation.

11. En savoir plus sur les fonctionnalités d’IA de sécurité GitHub

Pour obtenir des conseils supplémentaires sur l’utilisation responsable des fonctionnalités d’IA de sécurité GitHub, nous vous recommandons de consulter la documentation suivante :