Lab 10.1: Named Pipes Windows

Objectifs d'Apprentissage

A la fin de ce laboratoire, vous serez capable de:

Comprendre le mecanisme des named pipes Windows
Creer un serveur et client de pipe en PowerShell
Enumerer les pipes existants sur un systeme
Comprendre les risques d'impersonation via pipes
Detecter les attaques utilisant les pipes

Duree Estimee

45 minutes

Prerequis

VM Windows 10/11
Connaissances PowerShell de base
Droits administrateur

Contexte Professionnel

Les named pipes sont utilises par:

Applications Windows pour communication locale
Services pour recevoir des commandes
Malwares pour communication furtive (Cobalt Strike, etc.)
Techniques d'escalade de privileges (Potato attacks)

Partie 1: Enumeration des Named Pipes

Etape 1.1: Lister les pipes actifs

PowerShell:

# Methode 1: Get-ChildItem
Get-ChildItem \\.\pipe\ | Select-Object Name

# Methode 2: .NET
[System.IO.Directory]::GetFiles("\\.\pipe\")

Questions:

Combien de pipes sont actifs sur votre systeme?
Reconnaissez-vous certains noms de pipes?

Etape 1.2: Identifier les pipes systeme

Les pipes suivants sont normaux sur Windows:

Pipe	Service
lsarpc	Local Security Authority
samr	Security Account Manager
netlogon	Authentification domaine
srvsvc	Service serveur
wkssvc	Service station de travail
spoolss	Service d'impression

Comparez votre liste avec ces pipes standards.

Etape 1.3: Utiliser PipeList (Sysinternals)

Si disponible:

pipelist.exe /accepteula

Questions: 3. PipeList montre-t-il plus d'informations que PowerShell? 4. Pouvez-vous voir quel processus utilise chaque pipe?

Partie 2: Creation d'un Serveur Pipe

Etape 2.1: Comprendre le flux

[Serveur Pipe]          [Client Pipe]
     |                       |
     |<-- 1. Cree le pipe -->|
     |                       |
     |<-- 2. Attend connexion|
     |                       |
     |<-- 3. Client se connecte
     |                       |
     |<-- 4. Echange de donnees -->|
     |                       |
     |<-- 5. Fermeture      |

Etape 2.2: Script serveur

Creez un fichier serveur_pipe.ps1:

# Serveur de Named Pipe
$pipeName = "TestLabPipe"

Write-Host "=== SERVEUR NAMED PIPE ===" -ForegroundColor Cyan
Write-Host "Creation du pipe: \\.\pipe\$pipeName" -ForegroundColor Yellow

# Creer le pipe serveur
Add-Type -AssemblyName System.Core
$pipe = New-Object System.IO.Pipes.NamedPipeServerStream(
    $pipeName,
    [System.IO.Pipes.PipeDirection]::InOut
)

Write-Host "En attente d'une connexion client..." -ForegroundColor Yellow
$pipe.WaitForConnection()
Write-Host "Client connecte!" -ForegroundColor Green

# Creer les flux de lecture/ecriture
$reader = New-Object System.IO.StreamReader($pipe)
$writer = New-Object System.IO.StreamWriter($pipe)
$writer.AutoFlush = $true

# Boucle de communication
Write-Host "Pret a recevoir des messages (tapez 'exit' pour quitter)" -ForegroundColor Yellow
Write-Host ""

while ($true) {
    # Lire le message du client
    $message = $reader.ReadLine()
    
    if ($message -eq "exit" -or $message -eq $null) {
        Write-Host "Fermeture de la connexion..." -ForegroundColor Red
        break
    }
    
    Write-Host "Recu: $message" -ForegroundColor White
    
    # Envoyer une reponse
    $response = "Echo: $message"
    $writer.WriteLine($response)
    Write-Host "Envoye: $response" -ForegroundColor Gray
}

# Nettoyage
$reader.Close()
$writer.Close()
$pipe.Close()
Write-Host "Pipe ferme." -ForegroundColor Red

Etape 2.3: Executer le serveur

.\serveur_pipe.ps1

Le serveur attend maintenant une connexion.

Partie 3: Creation d'un Client Pipe

Etape 3.1: Script client

Creez un fichier client_pipe.ps1:

# Client de Named Pipe
$pipeName = "TestLabPipe"
$serverName = "."  # Local

Write-Host "=== CLIENT NAMED PIPE ===" -ForegroundColor Cyan
Write-Host "Connexion a: \\$serverName\pipe\$pipeName" -ForegroundColor Yellow

# Creer le pipe client
Add-Type -AssemblyName System.Core
$pipe = New-Object System.IO.Pipes.NamedPipeClientStream(
    $serverName,
    $pipeName,
    [System.IO.Pipes.PipeDirection]::InOut
)

try {
    # Se connecter avec timeout de 5 secondes
    $pipe.Connect(5000)
    Write-Host "Connecte au serveur!" -ForegroundColor Green
    
    # Creer les flux
    $reader = New-Object System.IO.StreamReader($pipe)
    $writer = New-Object System.IO.StreamWriter($pipe)
    $writer.AutoFlush = $true
    
    # Boucle d'envoi
    Write-Host "Tapez vos messages (tapez 'exit' pour quitter):" -ForegroundColor Yellow
    Write-Host ""
    
    while ($true) {
        $message = Read-Host ">"
        
        if ($message -eq "exit") {
            $writer.WriteLine("exit")
            break
        }
        
        # Envoyer le message
        $writer.WriteLine($message)
        
        # Lire la reponse
        $response = $reader.ReadLine()
        Write-Host "Reponse: $response" -ForegroundColor Gray
    }
    
    # Nettoyage
    $reader.Close()
    $writer.Close()
    $pipe.Close()
    
} catch {
    Write-Host "Erreur: $_" -ForegroundColor Red
}

Write-Host "Connexion fermee." -ForegroundColor Red

Etape 3.2: Tester la communication

Terminal 1: Executez le serveur
```
.\serveur_pipe.ps1
```
Terminal 2: Executez le client
```
.\client_pipe.ps1
```
Envoyez des messages depuis le client

Questions: 5. La communication fonctionne-t-elle? 6. Verifiez que le pipe apparait dans la liste pendant qu'il est actif

Partie 4: Analyse de Securite

Etape 4.1: Permissions sur les pipes

Par defaut, les pipes heritent des permissions du processus createur.

Verifier les permissions (necessite accesschk de Sysinternals):

accesschk.exe -accepteula \\.\pipe\TestLabPipe

Etape 4.2: Risque d'Impersonation

Concept: Un serveur pipe peut "impersonner" le client qui se connecte, c'est-a-dire utiliser son token de securite.

Pourquoi c'est dangereux:

Si un utilisateur privilegie se connecte a un pipe malveillant
Le serveur peut voler son token
Et executer des commandes avec ses privileges

Etape 4.3: Demonstration d'impersonation (lecture seule)

# Ce code montre comment un serveur POURRAIT impersonner un client
# NE PAS UTILISER EN PRODUCTION - A TITRE EDUCATIF

# Dans le serveur, apres WaitForConnection():
# $pipe.RunAsClient({ 
#     whoami  # Afficherait l'identite du client
# })

Questions: 7. Pourquoi l'impersonation est-elle dangereuse? 8. Comment un attaquant pourrait-il exploiter cela?

Partie 5: Detection et Defense

Etape 5.1: Detecter les pipes suspects

# Script de detection de pipes inhabituels
$knownPipes = @(
    "lsarpc", "samr", "netlogon", "srvsvc", "wkssvc", 
    "spoolss", "browser", "eventlog", "ntsvcs"
)

$currentPipes = Get-ChildItem \\.\pipe\ | Select-Object -ExpandProperty Name

$suspiciousPipes = $currentPipes | Where-Object {
    $pipe = $_
    -not ($knownPipes | Where-Object { $pipe -like "*$_*" })
}

if ($suspiciousPipes) {
    Write-Host "Pipes potentiellement suspects:" -ForegroundColor Yellow
    $suspiciousPipes | ForEach-Object {
        Write-Host "  - $_" -ForegroundColor Red
    }
} else {
    Write-Host "Aucun pipe suspect detecte." -ForegroundColor Green
}

Etape 5.2: Monitoring avec Sysmon

Si Sysmon est installe:

Event ID 17: Pipe Created
Event ID 18: Pipe Connected

# Voir les evenements pipe recents
Get-WinEvent -FilterHashtable @{
    LogName = 'Microsoft-Windows-Sysmon/Operational'
    ID = 17, 18
} -MaxEvents 20 | Format-Table TimeCreated, Message -Wrap

Questions: 9. Votre pipe de test a-t-il ete journalise? 10. Quelles informations Sysmon capture-t-il?

Livrables

Captures d'ecran:
- Liste des pipes de votre systeme
- Serveur et client en communication
- Script de detection execute
Reponses aux 10 questions
Analyse: (1 page)
- Expliquez comment les named pipes fonctionnent
- Decrivez les risques de securite associes
- Proposez des mesures de detection

Criteres d'Evaluation

Critere	Points
Enumeration des pipes	20%
Serveur/client fonctionnels	30%
Analyse de securite	25%
Script de detection	25%

Commandes de Reference

# Enumeration
Get-ChildItem \\.\pipe\
[System.IO.Directory]::GetFiles("\\.\pipe\")

# Sysinternals
pipelist.exe /accepteula
accesschk.exe \\.\pipe\NomPipe

# Sysmon
Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-Sysmon/Operational';ID=17,18}

Depannage

Le pipe ne se cree pas

Verifiez que le nom est unique
Executez en tant qu'administrateur

Le client ne peut pas se connecter

Verifiez que le serveur est lance d'abord
Verifiez le nom du pipe (sensible a la casse)
Verifiez le firewall

Timeout de connexion

Le serveur doit etre en attente AVANT que le client se connecte
Augmentez le timeout si necessaire

Lab developpe dans le cadre du cours Systemes d'Exploitation - MODULE 10

Objectifs d'Apprentissage​

Duree Estimee​

Prerequis​

Contexte Professionnel​

Partie 1: Enumeration des Named Pipes​

Etape 1.1: Lister les pipes actifs​

Etape 1.2: Identifier les pipes systeme​

Etape 1.3: Utiliser PipeList (Sysinternals)​

Partie 2: Creation d'un Serveur Pipe​

Etape 2.1: Comprendre le flux​

Etape 2.2: Script serveur​

Etape 2.3: Executer le serveur​

Partie 3: Creation d'un Client Pipe​

Etape 3.1: Script client​

Etape 3.2: Tester la communication​

Partie 4: Analyse de Securite​

Etape 4.1: Permissions sur les pipes​

Etape 4.2: Risque d'Impersonation​

Etape 4.3: Demonstration d'impersonation (lecture seule)​

Partie 5: Detection et Defense​

Etape 5.1: Detecter les pipes suspects​

Etape 5.2: Monitoring avec Sysmon​

Livrables​

Criteres d'Evaluation​

Commandes de Reference​

Depannage​

Le pipe ne se cree pas​

Le client ne peut pas se connecter​

Timeout de connexion​