PCTAMALOU

🔬 Mission pratique – Laboratoire (2 heures)

Scénario : Audit de sécurité d'un serveur exposé

Vous êtes chargé d'analyser un serveur Linux exposé sur Internet. Votre mission : identifier tous les ports ouverts, les services associés, et évaluer les risques.

sudo apt update
sudo apt install -y net-tools lsof nmap tcpdump telnet
# net-tools: netstat
# lsof: liste des fichiers ouverts (dont sockets)
# nmap: scanner de ports (semaine suivante)
# tcpdump: analyseur de paquets
# telnet: client TCP simpleCopier

Étapes détaillées : Analyse complète

1. Analyse des ports en écoute (Listening)
   Commencez par comprendre ce qui écoute sur votre machine :

   echo "=== PORTS EN ÉCOUTE (ss) ==="
   sudo ss -tulnp
   
   echo -e "\n=== ANALYSE DÉTAILLÉE ==="
   # Par protocole
   echo "TCP en écoute:"
   sudo ss -tlnp
   
   echo -e "\nUDP en écoute:"
   sudo ss -ulnp
   
   # Alternative avec netstat
   echo -e "\n=== AVEC NETSTAT (alternative) ==="
   sudo netstat -tulnp
   
   # Sauvegarde pour analyse
   sudo ss -tulnp > ports_listening.txt
   echo "Rapport sauvegardé dans ports_listening.txt"Copier

2. Analyse des connexions actives
   Identifiez ce qui communique actuellement :

   echo "=== CONNEXIONS ACTIVES ==="
   sudo ss -tunap
   
   echo -e "\n=== FILTRES PAR ÉTAT ==="
   echo "Connexions établies:"
   sudo ss -tan state established
   
   echo -e "\nConnexions en attente:"
   sudo ss -tan state listening
   
   echo -e "\nToutes les connexions TCP:"
   sudo ss -tan
   
   # Analyse des états TCP
   echo -e "\n=== RÉPARTITION DES ÉTATS TCP ==="
   sudo ss -tan | awk '{print $1}' | sort | uniq -c | sort -rn
   
   # Connexions sortantes vs entrantes
   echo -e "\n=== CONNEXIONS SORTANTES (source port > 49151) ==="
   sudo ss -tan state established | awk '$5 ~ /:[0-9]+$/ {split($5,a,":"); if(a[2] > 49151) print}' | head -10Copier

3. Analyse avec lsof (List Open Files)
   Alternative puissante pour voir les sockets ouverts :

   echo "=== ANALYSE AVEC LSOF ==="
   sudo lsof -i
   
   echo -e "\n=== PORTS EN ÉCOUTE AVEC PROCESSUS ==="
   sudo lsof -i -s TCP:LISTEN
   
   echo -e "\n=== CONNEXIONS TCP ÉTABLIES ==="
   sudo lsof -i -s TCP:ESTABLISHED
   
   echo -e "\n=== PAR PORT SPÉCIFIQUE ==="
   sudo lsof -i :22  # SSH
   sudo lsof -i :80  # HTTP
   sudo lsof -i :443 # HTTPS
   
   # Format détaillé
   sudo lsof -Pan -i tcp -i udpCopier

4. Observation d'un handshake TCP en direct
   Créez et observez une connexion TCP :

   # Dans le terminal 1 : Observation
   echo "Terminal 1 - Observation:"
   echo "Ouvrez un autre terminal pour l'étape 2"
   sudo tcpdump -i any -n "tcp port 80" &
   TCPDUMP_PID=$!
   
   # Dans le terminal 2 (ouvrez-en un nouveau) : Connexion
   echo "Terminal 2 - Connexion:"
   echo "Lancez cette commande dans un nouveau terminal:"
   echo "telnet httpbin.org 80"
   echo "Puis tapez: GET /html HTTP/1.1"
   echo "Puis tapez: Host: httpbin.org"
   echo "Puis appuyez deux fois sur Entrée"
   
   read -p "Appuyez sur Entrée quand c'est fait dans l'autre terminal..."
   
   # Nettoyage
   sudo kill $TCPDUMP_PID 2>/dev/null
   
   # Analyse des états pendant la connexion
   echo -e "\n=== ÉTATS PENDANT CONNEXION ==="
   sudo ss -tan state established | grep :80Copier

5. Script Python d'analyse automatique
   Créez un outil d'audit professionnel :

   #!/usr/bin/env python3
   """
   PCTAMALOU - Semaine 7 : Analyseur de ports et connexions
   Outils pour auditer les ports ouverts et les connexions actives
   """
   
   import subprocess
   import json
   import re
   from datetime import datetime
   from collections import defaultdict, Counter
   
   def run_command(cmd):
       """Exécute une commande et retourne la sortie"""
       try:
           result = subprocess.run(cmd, shell=True, capture_output=True, text=True, check=True)
           return result.stdout
       except subprocess.CalledProcessError as e:
           return f"Erreur: {e}"
   
   def parse_ss_output(output):
       """Parse la sortie de ss -tulnp"""
       lines = output.strip().split('\n')
       listening_ports = []
       
       for line in lines[1:]:  # Skip header
           if not line.strip():
               continue
           
           # Format: Netid State  Recv-Q Send-Q Local Address:Port Peer Address:Port Process
           parts = line.split()
           if len(parts) >= 6:
               try:
                   netid = parts[0]
                   state = parts[1]
                   local = parts[4]
                   peer = parts[5]
                   process = ' '.join(parts[6:]) if len(parts) > 6 else ''
                   
                   # Extraction du port
                   port_match = re.search(r':(\d+)$', local)
                   if port_match:
                       port = int(port_match.group(1))
                       
                       # Extraction IP
                       ip_match = re.match(r'([^:]+):', local)
                       ip = ip_match.group(1) if ip_match else '*'
                       
                       listening_ports.append({
                           'protocol': 'TCP' if 'tcp' in netid.lower() else 'UDP',
                           'state': state,
                           'ip': ip,
                           'port': port,
                           'process': process,
                           'full_line': line
                       })
               except (IndexError, ValueError):
                   continue
       
       return listening_ports
   
   def analyze_ports(ports):
       """Analyse les ports pour détecter les risques"""
       risks = []
       well_known_ports = {
           21: 'FTP (risque: authentification claire)',
           22: 'SSH (risque: bruteforce constant)',
           23: 'Telnet (risque: tout en clair)',
           25: 'SMTP (risque: relais email)',
           53: 'DNS (risque: amplification DDoS)',
           80: 'HTTP (risque: web attacks)',
           443: 'HTTPS (risque: moins mais surveiller)',
           445: 'SMB (risque: EternalBlue, partages)',
           1433: 'MSSQL (risque: bruteforce)',
           3306: 'MySQL (risque: accès base)',
           3389: 'RDP (risque: ransomwares)',
           5432: 'PostgreSQL (risque: accès base)',
           5900: 'VNC (risque: accès écran)',
           8080: 'HTTP Alt (risque: souvent oublié)'
       }
       
       for port_info in ports:
           port = port_info['port']
           
           # Détection des risques
           if port in well_known_ports:
               risk_level = 'HAUT' if port in [21, 23, 445, 3389] else 'MOYEN'
               risks.append({
                   'port': port,
                   'service': well_known_ports[port],
                   'risk': risk_level,
                   'protocol': port_info['protocol'],
                   'process': port_info['process']
               })
           
           # Ports non standard mais ouverts
           elif 1 <= port <= 1023 and port not in well_known_ports:
               risks.append({
                   'port': port,
                   'service': 'Service système non standard',
                   'risk': 'MOYEN-ÉLEVÉ',
                   'protocol': port_info['protocol'],
                   'process': port_info['process'],
                   'note': 'Port well-known mais service non standard'
               })
       
       return risks
   
   def generate_report(listening_ports, active_connections, risks):
       """Génère un rapport d'audit"""
       timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
       
       report = {
           'timestamp': timestamp,
           'summary': {
               'total_listening': len(listening_ports),
               'total_established': len([c for c in active_connections if c['state'] == 'ESTAB']),
               'high_risk_ports': len([r for r in risks if r['risk'] == 'HAUT']),
               'medium_risk_ports': len([r for r in risks if r['risk'] == 'MOYEN'])
           },
           'listening_ports': listening_ports,
           'risks': risks,
           'recommendations': []
       }
       
       # Génération des recommandations
       if report['summary']['high_risk_ports'] > 0:
           report['recommendations'].append(
               f"Fermer immédiatement {report['summary']['high_risk_ports']} port(s) à risque élevé"
           )
       
       if report['summary']['total_listening'] > 10:
           report['recommendations'].append(
               "Réduire la surface d'attaque: trop de ports ouverts"
           )
       
       # Recommandations spécifiques
       for risk in risks:
           if risk['port'] == 23:
               report['recommendations'].append("REMPLACER Telnet (port 23) par SSH (port 22)")
           elif risk['port'] == 21:
               report['recommendations'].append("REMPLACER FTP (port 21) par SFTP/SCP sur SSH")
           elif risk['port'] == 3389 and risk['protocol'] == 'TCP':
               report['recommendations'].append("Sécuriser RDP (port 3389) avec VPN ou saut SSH")
       
       return report
   
   def main():
       print("🔍 PCTAMALOU - Audit des ports et connexions")
       print("=" * 60)
       
       # 1. Collecte des données
       print("\n[1/4] Collecte des ports en écoute...")
       ss_output = run_command("sudo ss -tulnp 2>/dev/null || ss -tulnp")
       listening_ports = parse_ss_output(ss_output)
       
       print("[2/4] Analyse des connexions actives...")
       established_output = run_command("ss -tan state established 2>/dev/null || netstat -tan | grep ESTABLISHED")
       
       # 2. Analyse des risques
       print("[3/4] Évaluation des risques...")
       risks = analyze_ports(listening_ports)
       
       # 3. Génération du rapport
       print("[4/4] Génération du rapport...")
       
       # Analyse des connexions actives simplifiée
       active_connections = []
       for line in established_output.strip().split('\n'):
           if line and 'ESTAB' in line:
               active_connections.append({'state': 'ESTAB', 'line': line})
       
       report = generate_report(listening_ports, active_connections, risks)
       
       # 4. Affichage
       print(f"\n📊 RAPPORT D'AUDIT - {report['timestamp']}")
       print(f"• Ports en écoute: {report['summary']['total_listening']}")
       print(f"• Connexions établies: {report['summary']['total_established']}")
       print(f"• Ports à risque élevé: {report['summary']['high_risk_ports']}")
       print(f"• Ports à risque moyen: {report['summary']['medium_risk_ports']}")
       
       if risks:
           print("\n⚠️  PORTS À RISQUE DÉTECTÉS:")
           for risk in risks:
               print(f"  • Port {risk['port']} ({risk['protocol']}): {risk['service']}")
               print(f"    Risque: {risk['risk']} - Processus: {risk['process'][:50]}")
       
       if report['recommendations']:
           print("\n💡 RECOMMANDATIONS:")
           for i, rec in enumerate(report['recommendations'], 1):
               print(f"  {i}. {rec}")
       
       # 5. Export JSON
       with open('port_audit_report.json', 'w') as f:
           json.dump(report, f, indent=2, default=str)
       print(f"\n💾 Rapport exporté: port_audit_report.json")
       
       # 6. Liste complète des ports
       print("\n📋 LISTE COMPLÈTE DES PORTS EN ÉCOUTE:")
       for port in listening_ports:
           print(f"  {port['protocol']} {port['ip']}:{port['port']} - {port['state']} - {port['process'][:30]}")
   
   if __name__ == "__main__":
       main()Copier

6. Exercices pratiques avancés
   

   Exercice 1 : Détection de connexions suspectes

   # Recherche de connexions vers des ports inhabituels
   echo "=== CONNEXIONS VERS PORTS NON STANDARD ==="
   sudo ss -tan state established | awk '$5 ~ /:[0-9]+$/ {
       split($5, a, ":");
       port = a[2];
       if (port < 1 || port > 65535) next;
       if (port != 22 && port != 80 && port != 443 && port != 53) {
           print "Connexion suspecte:", $0;
       }
   }' | head -20
   
   # Connexions sortantes nombreuses (possible beaconing)
   echo -e "\n=== IPS AVEC PLUSIEURS CONNEXIONS SORTANTES ==="
   sudo ss -tan state established | awk '$5 ~ /:/ {
       split($5, a, ":");
       ip = a[1];
       conns[ip]++;
   }
   END {
       for (ip in conns) {
           if (conns[ip] > 10 && ip != "0.0.0.0" && ip != "127.0.0.1") {
               print ip, "a", conns[ip], "connexions établies";
           }
       }
   }' | sort -k3 -nrCopier

   Exercice 2 : Monitoring en temps réel

   # Watch des connexions (rafraîchissement toutes les 2 secondes)
   watch -n 2 "sudo ss -tan state established | tail -20"
   
   # Log des nouvelles connexions TCP
   sudo tcpdump -i any -n "tcp[tcpflags] & (tcp-syn) != 0 and (tcp[tcpflags] & (tcp-ack) == 0)" -c 10
   
   # Script de monitoring simple
   cat > monitor_ports.sh << 'EOF'
   #!/bin/bash
   echo "Monitoring des ports - PCTAMALOU S07"
   echo "Appuyez sur Ctrl+C pour arrêter"
   
   while true; do
       clear
       echo "=== $(date) ==="
       echo ""
       echo "Ports en écoute:"
       sudo ss -tlnp | head -15
       echo ""
       echo "Connexions établies:"
       sudo ss -tan state established | head -15
       sleep 5
   done
   EOF
   chmod +x monitor_ports.sh
   # ./monitor_ports.shCopier