Elouan

Les processus Windows et leur arborescence normale

Qui lance qui au démarrage de Windows, à quoi ressemble un système sain, et comment repérer le processus qui n'a rien à faire là.

Elouan

Série Systèmes Windows et Linux · article 1 sur 6
  1. Les processus Windows et leur arborescence normale
  2. Comptes, SID et droits sous Windows
  3. Lire les journaux Windows
  4. La persistance sous Windows
  5. Linux : utilisateurs, permissions et processus
  6. Linux : journaux et persistance

Sur un poste Windows qui vient de démarrer, une centaine de processus tournent déjà. Presque tous sont légitimes, et ils suivent une organisation très précise. Connaître cette organisation, c’est savoir repérer immédiatement celui qui n’a rien à faire là.

Processus, PID et PPID

Un processus, c’est un programme en cours d’exécution, avec sa propre mémoire, ses propres droits et un ou plusieurs threads qui exécutent le code.

Chaque processus a :

  • un PID (Process ID), son numéro unique tant qu’il tourne ;
  • un PPID (Parent PID), le numéro du processus qui l’a lancé ;
  • un utilisateur sous lequel il s’exécute (SYSTEM, un service, ou l’utilisateur connecté) ;
  • une ligne de commande et un chemin vers son exécutable.

La relation parent → enfant forme une arborescence. C’est elle qu’on regarde en premier quand on cherche quelque chose d’anormal, parce qu’un attaquant peut copier un nom, mais il a beaucoup plus de mal à imiter le bon parent.

Les outils pour voir l’arborescence

Le Gestionnaire des tâches n’affiche pas les parents. Pour ça, on utilise Process Explorer (Sysinternals), System Informer (ex-Process Hacker), ou, en ligne de commande : Get-CimInstance Win32_Process | Select ProcessId, ParentProcessId, Name, CommandLine

Le démarrage, étape par étape

La chaîne normale, telle que la décrit Windows Internals et que la résume le poster « Hunt Evil » du SANS :

System (PID 4)
└── smss.exe                      Session Manager, la première vraie étape
    ├── [session 0]
    │   ├── csrss.exe
    │   └── wininit.exe
    │       ├── services.exe       Gestionnaire des services
    │       │   ├── svchost.exe -k …   (beaucoup)
    │       │   ├── spoolsv.exe, MsMpEng.exe, …
    │       └── lsass.exe          Authentification
    └── [session 1, 2, …]  une par utilisateur connecté
        ├── csrss.exe
        └── winlogon.exe
            ├── LogonUI.exe        L'écran de connexion
            └── userinit.exe → explorer.exe   (userinit se termine)

Quelques points qui surprennent la première fois :

  • smss.exe se duplique pour chaque session, puis la copie se termine. C’est pour ça que csrss.exe, wininit.exe et winlogon.exe apparaissent sans parent visible : leur parent n’existe plus.
  • explorer.exe apparaît lui aussi sans parent, parce que userinit.exe se termine juste après l’avoir lancé.
  • La session 0 est réservée aux services. Les utilisateurs sont dans les sessions 1 et suivantes.

Les processus à connaître par cœur

ProcessusParent normalInstancesCheminÀ retenir
Systemaucun (PID 4)1(noyau)Le noyau et ses threads
smss.exeSystem1 durableSystem32Gestionnaire de sessions
csrss.exesmss.exe (terminé)1 par sessionSystem32Sous-système Win32
wininit.exesmss.exe (terminé)1System32Lance services et lsass
winlogon.exesmss.exe (terminé)1 par session interactiveSystem32Gère l’ouverture de session
services.exewininit.exe1System32Lance et gère les services
svchost.exeservices.exeBeaucoupSystem32Toujours un argument -k
lsass.exewininit.exe1 seuleSystem32Authentification, cible n°1 du vol d’identifiants
explorer.exeuserinit.exe (terminé)1 par utilisateurC:\WindowsLe bureau et l’explorateur

lsass.exe, la cible favorite

lsass.exe garde en mémoire des éléments d’authentification des utilisateurs connectés. C’est pour ça que des outils comme Mimikatz cherchent à lire sa mémoire (technique T1003.001 de MITRE ATT&CK). Un deuxième lsass.exe, un lsass.exe dont le parent n’est pas wininit.exe, ou un programme inhabituel qui ouvre un accès à la mémoire de lsass.exe (événement Sysmon 10) sont des alertes sérieuses.

Repérer l’intrus

Un attaquant qui lance un programme sur une machine essaie souvent de le faire passer pour un processus système. Les vérifications à faire, dans l’ordre :

  1. Le nom exact. svch0st.exe (un zéro), scvhost.exe, lsasss.exe, explore.exe. Une lettre suffit.
  2. Le chemin. Un svchost.exe dans C:\Users\Public\ ou C:\ProgramData\ n’est pas le vrai.
  3. Le parent. Un svchost.exe lancé par explorer.exe au lieu de services.exe.
  4. Le nombre d’instances. Deux lsass.exe, deux wininit.exe.
  5. L’utilisateur. Un lsass.exe qui ne tourne pas en SYSTEM.
  6. La signature. Les binaires système sont signés par Microsoft.

Les enchaînements suspects

Au-delà des processus système, certaines relations parent → enfant sont typiques d’une attaque. Les plus classiques :

ParentEnfantCe que ça évoque
winword.exe, excel.exe, outlook.exepowershell.exe, cmd.exe, mshta.exe, wscript.exeDocument piégé (macro)
w3wp.exe (IIS), httpd, tomcatcmd.exe, powershell.exe, whoami.exeWeb shell sur un serveur
services.execmd.exe avec une commande inhabituelleService créé pour exécuter du code (PsExec et ses variantes)
wmiprvse.exepowershell.exe, cmd.exeExécution à distance par WMI
rundll32.exe, regsvr32.exesans arguments ou avec une URLDétournement d’un binaire légitime

Ces binaires légitimes détournés s’appellent des LOLBins (Living Off the Land Binaries) : l’attaquant utilise les outils déjà présents sur la machine pour éviter d’apporter les siens.

Un enchaînement réel, en simplifié

outlook.exe → winword.exe (pièce jointe ouverte) → cmd.exe /c powershell -enc JABzAD0A… → connexion réseau vers une IP inconnue. Chaque maillon pris seul peut sembler banal. C’est la chaîne qui raconte l’attaque.

Services, registre et DLL en deux mots

Trois notions reviennent dans tous les articles suivants :

  • Un service est un programme lancé par services.exe, souvent au démarrage et sans utilisateur connecté. Beaucoup de services partagent un même svchost.exe (tasklist /svc pour voir lesquels).
  • Le registre est la base de configuration de Windows. Les grandes ruches : HKLM (la machine : SYSTEM, SOFTWARE, SAM, SECURITY) et HKCU (l’utilisateur courant, stocké dans son NTUSER.DAT).
  • Une DLL est une bibliothèque de code chargée par un processus. Si un attaquant arrive à faire charger sa DLL par un programme légitime, son code s’exécute avec l’identité de ce programme.

Le prochain article explique sous quelle identité tournent ces processus : comptes, SID et droits.

L'essentiel

  • Chaque processus a un PID et un PPID (le PID de son parent). L'arborescence parent → enfant est la première chose à regarder.
  • Chaîne de démarrage : System (PID 4) → smss.exe → wininit.exe (session 0) et winlogon.exe (session utilisateur), accompagnés de csrss.exe.
  • wininit.exe lance services.exe et lsass.exe. services.exe lance les svchost.exe. winlogon.exe lance userinit.exe, qui lance explorer.exe puis se termine.
  • lsass.exe : une seule instance, parent wininit.exe, dans C:\Windows\System32. Un deuxième lsass ou un lsass ailleurs est une alerte.
  • Plusieurs svchost.exe, c'est normal : leur parent doit être services.exe et leur ligne de commande contient -k.
  • Un processus de bureautique (winword.exe, excel.exe) qui lance powershell.exe, cmd.exe ou mshta.exe est l'un des signaux les plus classiques d'une attaque.

Idées reçues

Il y a quinze processus svchost.exe sur un poste. Est-ce suspect ?

L'erreur courante. Dire oui, parce qu'un nom de processus ne devrait apparaître qu'une fois.

En réalité. Non, c'est normal : svchost.exe héberge des groupes de services, et Windows en lance beaucoup. Ce qui serait suspect : un svchost.exe dont le parent n'est pas services.exe, qui ne tourne pas depuis C:\Windows\System32, qui n'a pas d'argument -k, ou qui ouvre des connexions réseau inhabituelles.

explorer.exe n'a pas de parent visible dans l'arborescence. Faut-il s'inquiéter ?

L'erreur courante. Conclure à une injection ou à un processus orphelin malveillant.

En réalité. C'est normal. explorer.exe est lancé par userinit.exe, qui se termine juste après. Le parent n'existe donc plus, et les outils affichent explorer.exe à la racine. Même chose pour csrss.exe, wininit.exe et winlogon.exe, dont le smss.exe parent se termine aussi.

Comment reconnaître un faux processus système ?

L'erreur courante. Se fier uniquement au nom.

En réalité. Le nom ne suffit pas : un malware peut s'appeler lsass.exe. On vérifie le chemin (System32 et pas un dossier temporaire), le parent attendu, le nombre d'instances, l'utilisateur sous lequel il tourne, la signature numérique, et les noms presque identiques (svch0st.exe, lsasss.exe, scvhost.exe).

Quel est le PID du processus System ?

L'erreur courante. Répondre 0.

En réalité. 4. Le PID 0 correspond au processus « System Idle Process », qui n'est pas un vrai processus mais représente le temps où le processeur ne fait rien.

Pourquoi les services tournent-ils dans la session 0 ?

L'erreur courante. Dire que c'est pour les performances.

En réalité. Depuis Windows Vista, la session 0 est réservée aux services et isolée des sessions des utilisateurs (session 1 et suivantes). Ça empêche un programme utilisateur d'interagir directement avec un service qui tourne avec des droits élevés, une ancienne technique d'élévation de privilèges (shatter attacks).

Tester ses connaissances

Références

  • Windows Internals, Part 1 (7e éd.)Pavel Yosifovich, Alex Ionescu, Mark E. Russinovich, David A. Solomon · Microsoft Press
  • Troubleshooting with the Windows Sysinternals Tools (2e éd.)Mark Russinovich, Aaron Margosis · Microsoft Press
  • Applied Incident ResponseSteve Anson · Wiley

Textes de référence en ligne