Comprendre et Analyser les Attaques Web via les Logs Apache

🎯 Pourquoi analyser les logs Apache ?

Les trois objectifs de l'analyse de logs

1. Détection d'intrusion : Identifier les tentatives d'exploitation (SQL injection, path traversal, brute-force)
2. Cartographie des menaces : Comprendre d'où viennent les attaques et quels outils sont utilisés
3. Renseignement actionnable : Transformer du bruit en décisions (bloquer des IPs, patcher des services, ajuster le WAF)

🔍 Anatomie d'une ligne de log Apache

Apache utilise le Combined Log Format, qui enregistre chaque requête HTTP sur une ligne. Avant de parser quoi que ce soit, il faut comprendre ce que contient cette ligne.

203.0.113.42 - - [21/Aug/2025:10:30:01 +0200] "GET /wp-login.php HTTP/1.1" 404 502 "-" "Mozilla/5.0 (compatible; Nmap Scripting Engine)"

Décryptage champ par champ

⚙️ Stratégie d'extraction : pourquoi les expressions régulières ?

Pourquoi pas un simple split() ?

On pourrait être tenté de découper la ligne par espaces, mais cela échoue dès qu'un champ contient lui-même des espaces :

"GET /page?param=hello world HTTP/1.1"

Les guillemets, crochets et caractères spéciaux rendent le format contextuellement structuré. Les regex permettent de capturer ces structures avec précision.

Construction progressive de la regex

Décortiquons la regex par blocs :

💻 Implémentation : du parsing à la visualisation

Étape 1 : Parser les logs

Maintenant qu'on comprend la structure, on peut extraire les informations avec PowerShell :

$logFilePath = "C:\Temp\access.log"

# Regex robuste compatible avec User-Agents complexes
$logPattern = '^(?<ip>[\d\.]+) \S+ \S+ \[(?<datetime>[^\]]+)\] "(?<method>\S+) (?<url>\S+) \S+" (?<status>\d{3}) (?<size>\S+) "[^"]*" "(?<useragent>.*)"'

$parsedLogs = Select-String -Path $logFilePath -Pattern $logPattern | ForEach-Object {
    [PSCustomObject]@{
        IPAddress = $_.Matches[0].Groups['ip'].Value
        DateTime  = $_.Matches[0].Groups['datetime'].Value
        Method    = $_.Matches[0].Groups['method'].Value
        URL       = $_.Matches[0].Groups['url'].Value
        Status    = [int]$_.Matches[0].Groups['status'].Value
        UserAgent = $_.Matches[0].Groups['useragent'].Value
    }
}

Write-Host "✅ $($parsedLogs.Count) lignes parsées avec succès"

Étape 2 : Identifier les indicateurs de compromission (IoC)

Les attaquants laissent des signatures caractéristiques. On filtre selon deux critères :

1. Codes HTTP 4xx : Erreurs client révélant des tentatives sur des ressources inexistantes
2. User-Agents suspects : Outils d'attaque connus (Nmap, SQLmap, Gobuster...)

# Enrichissement avec identification de l'outil
$suspicious = $parsedLogs | Where-Object { 
    $_.Status -ge 400 -and $_.Status -lt 500 
} | ForEach-Object {
    $tool = switch -Regex ($_.UserAgent) {
        'nmap|Nmap'        { 'Nmap' }
        'sqlmap'           { 'SQLmap' }
        'gobuster|dirb'    { 'Directory Brute-Force' }
        'nikto'            { 'Nikto Scanner' }
        'masscan'          { 'Masscan' }
        default            { 'Inconnu' }
    }
    $_ | Add-Member -NotePropertyName Tool -NotePropertyValue $tool -PassThru
}

Write-Host "🚨 $($suspicious.Count) requêtes suspectes détectées"

Étape 3 : Géolocalisation et agrégation

On identifie les top 20 IPs attaquantes et on les géolocalise pour comprendre l'origine géographique des menaces.

$mapPoints = foreach ($ipGroup in ($suspicious | Group-Object IPAddress | Sort-Object -Descending Count | Select-Object -First 20)) {
    $ip = $ipGroup.Name
    $ipAnon = ($ip -split '\.')[0..2] -join '.' + '.0/24'

    # Rate-limiting : ip-api.com limite à 45 req/min
    Start-Sleep -Milliseconds 1500

    try {
        $geo = Invoke-RestMethod "http://ip-api.com/json/$ip"
        if ($geo.status -eq 'success') {
            [PSCustomObject]@{
                ip        = $ipAnon
                lat       = $geo.lat
                lon       = $geo.lon
                city      = $geo.city
                country   = $geo.country
                isp       = $geo.isp
                errorCnt  = $ipGroup.Count
                tool      = ($ipGroup.Group.Tool | Sort-Object -Unique) -join ', '
                topUrls   = ($ipGroup.Group.URL | Group-Object | Sort-Object -Descending Count | Select-Object -First 5).Name
            }
        }
    } catch { 
        Write-Warning "⚠️ IP $ip non géolocalisable" 
    }
}

Étape 4 : Génération de la carte interactive

On utilise Leaflet.js avec clustering pour visualiser les attaques sur une carte mondiale. Chaque marqueur affiche les détails de l'attaque au clic.

$jsData = $mapPoints | ConvertTo-Json -Compress

$htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <title>Carte des Attaques Web - Analyse Géographique</title>
    <meta charset="utf-8" />
    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
    <link rel="stylesheet" href="https://unpkg.com/leaflet.markercluster@1.5.3/dist/MarkerCluster.css" />
    <style>
        body { margin: 0; font-family: Arial, sans-serif; }
        #map { height: 100vh; }
        #exportCSV {
            position: absolute;
            top: 10px;
            right: 10px;
            z-index: 999;
            padding: 10px 16px;
            background: #007bff;
            color: white;
            border: none;
            border-radius: 4px;
            cursor: pointer;
            font-weight: bold;
        }
        #exportCSV:hover { background: #0056b3; }
    </style>
</head>
<body>
<div id="map"></div>
<button id="exportCSV">📥 Exporter CSV</button>

<script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
<script src="https://unpkg.com/leaflet.markercluster@1.5.3/dist/leaflet.markercluster.js"></script>
<script>
    const map = L.map('map').setView([20, 0], 2);
    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
        attribution: '© OpenStreetMap contributors'
    }).addTo(map);

    const markers = L.markerClusterGroup();
    const ipData = $jsData;

    ipData.forEach(point => {
        const urlList = point.topUrls.map(u => `<li><code>${u}</code></li>`).join('');
        const popup = `
            <h3 style="margin-top:0">${point.ip}</h3>
            <p><strong>📍 ${point.city}, ${point.country}</strong></p>
            <p>🌐 ISP : ${point.isp}</p>
            <p>🚨 Erreurs 4xx détectées : <strong>${point.errorCnt}</strong></p>
            <p>🔧 Outils identifiés : <strong>${point.tool}</strong></p>
            <h4>Top URLs ciblées :</h4>
            <ul style="margin:0;padding-left:20px">${urlList}</ul>
        `;
        markers.addLayer(L.marker([point.lat, point.lon]).bindPopup(popup));
    });
    map.addLayer(markers);

    // Export CSV
    document.getElementById('exportCSV').onclick = () => {
        const csvContent = 'data:text/csv;charset=utf-8,' +
            'IP,Latitude,Longitude,Ville,Pays,ISP,NombreErreurs,Outils\\n' +
            ipData.map(p => 
                `"${p.ip}",${p.lat},${p.lon},"${p.city}","${p.country}","${p.isp}",${p.errorCnt},"${p.tool}"`
            ).join('\\n');
        
        const link = document.createElement('a');
        link.setAttribute('href', encodeURI(csvContent));
        link.setAttribute('download', `attaques_web_${new Date().toISOString().split('T')[0]}.csv`);
        link.click();
    };
</script>
</body>
</html>
"@

$reportPath = "C:\Temp\rapport_attaques_web.html"
$htmlContent | Out-File -FilePath $reportPath -Encoding UTF8
Write-Host "✅ Rapport généré : $reportPath"
Start-Process $reportPath

🚀 Aller plus loin : optimisations et limites

Performance : PowerShell vs outils Unix

Scalabilité : traiter des fichiers volumineux

Pour des logs >100MB, adaptez le script :

# Traitement par batch de 10000 lignes
Get-Content $logFilePath -ReadCount 10000 | ForEach-Object {
    $batch = $_
    # Traiter le batch...
}

Sécurité : patterns d'attaque avancés

Enrichissez la détection avec des patterns spécifiques :

• SQL Injection : URLs contenant ' OR 1=1, UNION SELECT
• Path Traversal : ../../../etc/passwd
• XSS : <script>, javascript:
• Command Injection : ; ls -la, | cat /etc/passwd

Automatisation : surveillance continue

Planifiez l'exécution quotidienne avec Task Scheduler :

$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-File C:\Scripts\AnalyseLogs.ps1"
$trigger = New-ScheduledTaskTrigger -Daily -At 3AM
Register-ScheduledTask -TaskName "AnalyseLogsApache" -Action $action -Trigger $trigger

🎓 Conclusion : de la donnée brute à l'intelligence