Comment auditer et sécuriser les extensions VS Code après des attaques sur la chaîne d'approvisionnement

Commencez par obtenir une image complète des extensions actuellement installées dans votre environnement VS Code. Cet audit de base est crucial pour identifier les risques de sécurité potentiels.

code --list-extensions

Cette commande affiche toutes les extensions installées au format publisher.extension-name. Pour une vue plus détaillée avec les numéros de version, utilisez :

code --list-extensions --show-versions

Créez une feuille de calcul ou un fichier texte pour documenter chaque extension. Pour chacune, notez :

• Nom de l'extension et éditeur
• Dernière fois que vous l'avez réellement utilisée
• Si elle est essentielle pour votre flux de travail
• Nombre de téléchargements et date de la dernière mise à jour (vérifiez dans la vue Extensions de VS Code)

Vérification : Ouvrez VS Code, allez dans Extensions (Ctrl+Shift+X), et comparez la liste GUI avec votre sortie de commande pour assurer l'exactitude.

Supprimez maintenant systématiquement les extensions qui posent un risque inutile. Commencez par les extensions que vous avez identifiées comme inutilisées lors de votre audit.

code --uninstall-extension publisher.extension-name

Pour une suppression en masse, créez un script. Sur Linux/macOS :

#!/bin/bash
# Liste des extensions à supprimer
extensions_to_remove=(
    "publisher1.extension1"
    "publisher2.extension2"
    "publisher3.extension3"
)

for ext in "${extensions_to_remove[@]}"; do
    echo "Suppression de $ext..."
    code --uninstall-extension "$ext"
done

Portez une attention particulière aux extensions qui ont été signalées dans les récents rapports de sécurité. À partir de 2026, des extensions comme certaines versions de Live Server et Markdown Preview Enhanced ont eu des vulnérabilités documentées.

Vérification : Exécutez code --list-extensions à nouveau pour confirmer que les extensions ont été supprimées.

VS Code 1.97 a introduit la vérification des éditeurs de confiance. Accédez au système de gestion de la confiance via la palette de commandes.

Ouvrez la palette de commandes (Ctrl+Shift+P) et exécutez :

Extensions : Gérer les éditeurs d'extensions de confiance

Cela ouvre une boîte de dialogue affichant tous les éditeurs que vous avez précédemment approuvés. Passez en revue chacun d'eux :

• Cherchez la coche bleue indiquant les éditeurs vérifiés
• Retirez la confiance des éditeurs que vous ne reconnaissez plus
• Les éditeurs vérifiés ont prouvé la propriété du domaine et maintenu une bonne réputation pendant plus de 6 mois

Pour les extensions restantes, vérifiez manuellement chaque éditeur :

1. Ouvrez l'extension dans le Marketplace
2. Vérifiez le profil et le site web de l'éditeur
3. Cherchez le statut vérifié (coche bleue)
4. Examinez le dépôt GitHub de l'extension si disponible

Configurez les invites de confiance automatiques en ajoutant ceci à votre settings.json :

{
    "extensions.autoCheckUpdates": true,
    "extensions.ignoreRecommendations": false,
    "security.workspace.trust.enabled": true
}

Vérification : Installez une nouvelle extension d'un éditeur non approuvé - vous devriez voir une boîte de dialogue de confirmation de confiance.

VSCan est un outil spécialisé pour analyser les extensions VS Code à la recherche de comportements risqués et de permissions suspectes. Installez-le comme dépendance de développement ou outil global.

Pour les environnements Node.js :

npm install -g vscan

Ou en utilisant Python pip :

pip install vscan

Créez un script de scan de sécurité pour auditer régulièrement vos extensions :

#!/bin/bash
# Script d'audit de sécurité des extensions VS Code

echo "Démarrage de l'audit de sécurité des extensions VS Code..."
echo "Date : $(date)"
echo "======================================"

# Obtenir la liste des extensions installées
echo "Extensions installées :"
code --list-extensions --show-versions

echo ""
echo "Exécution de l'analyse VSCan..."
# Exécuter VSCan sur chaque extension (ajuster le chemin si nécessaire)
for ext in $(code --list-extensions); do
    echo "Analyse : $ext"
    vscan analyze "$ext" --output-format json >> extension_audit_$(date +%Y%m%d).json
done

echo "Audit terminé. Vérifiez extension_audit_$(date +%Y%m%d).json pour les résultats."

Rendez le script exécutable et exécutez-le :

chmod +x audit_extensions.sh
./audit_extensions.sh

Vérification : Vérifiez le fichier JSON généré pour toute découverte à haut risque. VSCan signale les extensions avec une activité réseau suspecte, un accès au système de fichiers ou des modèles d'exécution de code.

Installez l'extension OWASP Dependency-Check pour analyser les dépendances de votre projet à la recherche de vulnérabilités connues. Cela complète VSCan en se concentrant sur les bibliothèques que vos extensions pourraient utiliser.

Installez l'extension :

code --install-extension dependency-check.owasp-dependency-check

Configurez l'extension en créant un fichier de paramètres de l'espace de travail .vscode/settings.json :

{
    "owasp-dependency-check.enableAutoScan": true,
    "owasp-dependency-check.scanOnSave": true,
    "owasp-dependency-check.excludePatterns": [
        "**/node_modules/**",
        "**/vendor/**",
        "**/.git/**"
    ],
    "owasp-dependency-check.reportFormat": "JSON",
    "owasp-dependency-check.failOnCVSS": 7.0
}

Créez un fichier de configuration de vérification des dépendances dependency-check.properties :

# OWASP Dependency Check Configuration
data.directory=~/.dependency-check-data
format=JSON,HTML
suppression.file=dependency-check-suppressions.xml
failOnCVSS=7
retireJsAnalyzer.enabled=true
nodeAnalyzer.enabled=true
npmCPEAnalyzer.enabled=true

Exécutez une analyse manuelle pour tester la configuration :

dependency-check --project "VS Code Security Audit" --scan . --format JSON --format HTML

Vérification : Vérifiez que l'analyse génère des rapports aux formats JSON et HTML. Le rapport HTML offre une vue conviviale de toutes les vulnérabilités trouvées.

La confiance de l'espace de travail est une fonctionnalité de sécurité critique qui contrôle si le code dans un dossier de projet peut être exécuté par VS Code et les extensions. Configurez-la correctement pour éviter l'exécution de code malveillant.

Activez la confiance de l'espace de travail dans vos paramètres globaux :

{
    "security.workspace.trust.enabled": true,
    "security.workspace.trust.startupPrompt": "always",
    "security.workspace.trust.emptyWindow": false,
    "security.workspace.trust.banner": "always",
    "security.workspace.trust.untrustedFiles": "prompt"
}

Créez un fichier de politique de confiance de l'espace de travail workspace-trust-policy.json :

{
    "trustedFolders": [
        "/home/user/trusted-projects",
        "/Users/user/work/company-repos"
    ],
    "untrustedFileExtensions": [
        ".exe",
        ".bat",
        ".cmd",
        ".ps1"
    ],
    "allowedExtensionsInUntrustedWorkspaces": [
        "ms-vscode.vscode-json",
        "ms-python.python",
        "ms-vscode.cpptools"
    ]
}

Pour les environnements d'entreprise, configurez des listes blanches d'extensions via la stratégie de groupe ou la gestion de la configuration :

{
    "extensions.autoCheckUpdates": false,
    "extensions.autoUpdate": false,
    "extensions.ignoreRecommendations": true,
    "extensions.supportUntrustedWorkspaces": {
        "ms-vscode.vscode-json": {
            "supported": true,
            "restrictedConfigurations": []
        }
    }
}

Vérification : Ouvrez un dossier non fiable - VS Code devrait vous demander à propos de la confiance de l'espace de travail et restreindre la fonctionnalité des extensions jusqu'à ce que vous fassiez explicitement confiance à l'espace de travail.

Configurez une surveillance automatisée pour détecter de nouvelles vulnérabilités et un comportement suspect des extensions. Créez un script de surveillance qui s'exécute quotidiennement via cron ou le Planificateur de tâches.

Créez un script de surveillance complet extension_monitor.sh :

#!/bin/bash

# Script de surveillance continue des extensions VS Code
LOG_FILE="/var/log/vscode-security-monitor.log"
ALERT_EMAIL="security@yourcompany.com"
CURRENT_DATE=$(date '+%Y-%m-%d %H:%M:%S')

echo "[$CURRENT_DATE] Démarrage de la surveillance de sécurité des extensions VS Code" >> $LOG_FILE

# Vérifiez les nouvelles extensions
CURRENT_EXTENSIONS=$(code --list-extensions | sort)
LAST_EXTENSIONS=$(cat ~/.vscode-extensions-baseline 2>/dev/null || echo "")

if [ "$CURRENT_EXTENSIONS" != "$LAST_EXTENSIONS" ]; then
    echo "[$CURRENT_DATE] ALERTE : La liste des extensions a changé" >> $LOG_FILE
    echo "Nouvelles extensions détectées :" >> $LOG_FILE
    comm -13 <(echo "$LAST_EXTENSIONS") <(echo "$CURRENT_EXTENSIONS") >> $LOG_FILE
    
    # Envoyer un email d'alerte (configurer sendmail ou utiliser curl avec un service de messagerie)
    echo "Changements d'extensions détectés sur $(hostname)" | mail -s "Alerte de sécurité VS Code" $ALERT_EMAIL
fi

# Mettre à jour la base de référence
echo "$CURRENT_EXTENSIONS" > ~/.vscode-extensions-baseline

# Exécuter une analyse de vulnérabilité
vscan analyze --all-extensions --output-format json > /tmp/vscan_results.json

# Vérifiez les résultats de haute gravité
HIGH_SEVERITY=$(jq '.findings[] | select(.severity == "high")' /tmp/vscan_results.json)
if [ ! -z "$HIGH_SEVERITY" ]; then
    echo "[$CURRENT_DATE] CRITIQUE : Vulnérabilités de haute gravité trouvées" >> $LOG_FILE
    echo "$HIGH_SEVERITY" >> $LOG_FILE
    echo "Vulnérabilités critiques des extensions VS Code détectées" | mail -s "CRITIQUE : Alerte de sécurité VS Code" $ALERT_EMAIL
fi

echo "[$CURRENT_DATE] Surveillance terminée" >> $LOG_FILE

Configurez le cron job pour s'exécuter quotidiennement à 2h du matin :

crontab -e
# Ajoutez cette ligne :
0 2 * * * /path/to/extension_monitor.sh

Pour Windows, créez une version PowerShell et utilisez le Planificateur de tâches :

# extension_monitor.ps1
$LogFile = "C:\Logs\vscode-security-monitor.log"
$CurrentDate = Get-Date -Format "yyyy-MM-dd HH:mm:ss"

Add-Content -Path $LogFile -Value "[$CurrentDate] Démarrage de la surveillance"

# Obtenez les extensions actuelles
$CurrentExtensions = & code --list-extensions | Sort-Object
$BaselineFile = "$env:USERPROFILE\.vscode-extensions-baseline"

if (Test-Path $BaselineFile) {
    $LastExtensions = Get-Content $BaselineFile | Sort-Object
    $Diff = Compare-Object $LastExtensions $CurrentExtensions
    
    if ($Diff) {
        Add-Content -Path $LogFile -Value "[$CurrentDate] ALERTE : Les extensions ont changé"
        $Diff | Add-Content -Path $LogFile
    }
}

$CurrentExtensions | Out-File $BaselineFile

Vérification : Exécutez le script de surveillance manuellement d'abord pour vous assurer qu'il fonctionne correctement. Vérifiez le fichier journal pour une sortie correcte et testez les alertes par email.

Documentez vos politiques de sécurité des extensions et créez des procédures pour votre équipe. Cela garantit des pratiques de sécurité cohérentes dans toute votre organisation.

Créez un document de politique de sécurité des extensions vscode-extension-policy.md :

# Politique de Sécurité des Extensions VS Code

## Extensions Approuvées
- ms-python.python (Support Python)
- ms-vscode.cpptools (Support C++)
- eamodio.gitlens (Intégration Git)

## Extensions Interdites
- Toute extension avec des éditeurs non vérifiés
- Extensions avec des vulnérabilités connues
- Extensions nécessitant un accès large au système de fichiers

## Processus de Révision
1. Approbation de l'équipe de sécurité requise pour les nouvelles extensions
2. Révision mensuelle des extensions installées
3. Suppression immédiate des extensions signalées

## Réponse aux Incidents
1. Isoler les systèmes affectés
2. Documenter l'incident
3. Supprimer les extensions malveillantes
4. Mettre à jour les politiques de sécurité

Créez un fichier de configuration d'équipe qui peut être partagé via le contrôle de version :

{
    "recommendations": [
        "ms-python.python",
        "ms-vscode.cpptools",
        "eamodio.gitlens"
    ],
    "unwantedRecommendations": [
        "ms-vscode.live-server",
        "shd101wyy.markdown-preview-enhanced"
    ]
}

Enregistrez ceci sous .vscode/extensions.json dans vos dépôts de projet. Créez une liste de vérification de sécurité pour les développeurs :

# Liste de Vérification de Sécurité des Extensions
pre_installation:
  - [ ] Vérifier que l'éditeur est de confiance
  - [ ] Vérifier les permissions de l'extension
  - [ ] Examiner les mises à jour récentes et le journal des modifications
  - [ ] Confirmer le besoin commercial

post_installation:
  - [ ] Tester la fonctionnalité de l'extension
  - [ ] Surveiller les performances du système
  - [ ] Documenter l'installation dans le suivi d'équipe
  - [ ] Planifier une révision dans 90 jours

monthly_review:
  - [ ] Vérifier les mises à jour de sécurité
  - [ ] Vérifier le besoin commercial continu
  - [ ] Examiner les journaux d'accès si disponibles
  - [ ] Mettre à jour la documentation

Vérification : Partagez la politique avec votre équipe et assurez-vous que tout le monde comprend les procédures. Testez le processus de réponse aux incidents avec un événement de sécurité simulé.