CyberCode - Formation Cybersécurité Complète

Python pour la Cybersécurité

Maîtrisez Python pour l'automatisation de tâches de sécurité, l'analyse de logs, le scanning réseau et le développement d'outils de pentesting.

Durée totale 42 heures

Leçons 28

Exercices 45

Projets 6

Module 1 : Fondamentaux Python & Sécurité

6 heures

Débutant

3/5 complétés

Introduction à Python en Cybersécurité

Python est devenu le langage de référence en cybersécurité grâce à sa simplicité, sa lisibilité et sa richesse en bibliothèques spécialisées.

Pourquoi Python ?

Syntaxe claire : Même pour les débutants
Bibliothèques puissantes : Scapy, Requests, Paramiko, Cryptography
Rapidité de développement : Prototyper des outils en quelques lignes
Communauté active : Des milliers de ressources disponibles

📋 Ce que vous allez apprendre :

Manipuler les sockets réseau
Analyser des fichiers logs
Scanner des ports et services
Automatiser des tâches répétitives
Développer des outils de pentesting

Manipulation de Fichiers et Logs

L'analyse de logs est une compétence essentielle pour détecter des intrusions et des activités suspectes.

#!/usr/bin/env python3
# Analyseur de logs de sécurité
# Objectif : Détecter les tentatives de connexion suspectes

import re
from collections import defaultdict
from datetime import datetime, timedelta

class SecurityLogAnalyzer:
    def __init__(self, log_file):
        self.log_file = log_file
        self.suspicious_ips = defaultdict(list)
        self.alerts = []
        
        # Patterns pour détection d'attaques
        self.patterns = {
            'failed_login': r'Failed password for .* from (\d+\.\d+\.\d+\.\d+)',
            'invalid_user': r'Invalid user .* from (\d+\.\d+\.\d+\.\d+)',
            'brute_force': r'POSSIBLE BREAK-IN ATTEMPT',
            'port_scan': r'port scan detected from (\d+\.\d+\.\d+\.\d+)',
            'sql_injection': r'SQL injection attempt.*from (\d+\.\d+\.\d+\.\d+)'
        }
    
    def analyze(self):
        """Analyse complète du fichier de logs"""
        print("🔍 Analyse des logs de sécurité...")
        print("=" * 60)
        
        try:
            with open(self.log_file, 'r', encoding='utf-8', errors='ignore') as f:
                lines = f.readlines()
            
            total_lines = len(lines)
            print(f"📊 Fichier analysé : {self.log_file}")
            print(f"📄 Nombre de lignes : {total_lines}")
            print("-" * 60)
            
            # Analyser ligne par ligne
            for line_num, line in enumerate(lines, 1):
                self.analyze_line(line, line_num)
            
            # Générer le rapport
            self.generate_report()
            
        except FileNotFoundError:
            print(f"❌ Erreur : Fichier '{self.log_file}' non trouvé")
            print("Création d'un fichier de logs d'exemple...")
            self.create_sample_logs()
            self.analyze()
    
    def analyze_line(self, line, line_num):
        """Analyse une ligne de log"""
        for attack_type, pattern in self.patterns.items():
            match = re.search(pattern, line, re.IGNORECASE)
            if match:
                ip = match.group(1) if match.groups() else "N/A"
                timestamp = datetime.now().strftime("%H:%M:%S")
                
                # Stocker l'alerte
                alert = {
                    'line': line_num,
                    'type': attack_type,
                    'ip': ip,
                    'timestamp': timestamp,
                    'message': line.strip()[:100] + "..."
                }
                self.alerts.append(alert)
                
                # Compter par IP
                if ip != "N/A":
                    self.suspicious_ips[ip].append(alert)
    
    def generate_report(self):
        """Génère un rapport détaillé"""
        if not self.alerts:
            print("✅ Aucune activité suspecte détectée")
            return
        
        print("🚨 ALERTES DE SÉCURITÉ DÉTECTÉES")
        print("=" * 60)
        
        # Grouper par type d'attaque
        attacks_by_type = defaultdict(int)
        for alert in self.alerts:
            attacks_by_type[alert['type']] += 1
        
        # Afficher les statistiques
        for attack_type, count in attacks_by_type.items():
            readable_type = attack_type.replace('_', ' ').title()
            print(f"• {readable_type}: {count} occurrence(s)")
        
        print("-" * 60)
        
        # Identifier les IPs les plus actives
        if self.suspicious_ips:
            print("📋 IPs suspectes (top 5):")
            sorted_ips = sorted(self.suspicious_ips.items(), 
                              key=lambda x: len(x[1]), 
                              reverse=True)[:5]
            
            for ip, alerts in sorted_ips:
                severity = "HAUTE" if len(alerts) > 10 else "MOYENNE" if len(alerts) > 5 else "FAIBLE"
                print(f"  {ip}: {len(alerts)} alertes (Sévérité: {severity})")
        
        print("=" * 60)
        print(f"📈 Total d'alertes : {len(self.alerts)}")
    
    def create_sample_logs(self):
        """Crée des logs d'exemple pour la démonstration"""
        sample_logs = [
            "Jan  1 10:00:01 server sshd[1234]: Failed password for root from 192.168.1.100 port 22 ssh2",
            "Jan  1 10:00:02 server sshd[1234]: Failed password for root from 192.168.1.100 port 22 ssh2",
            "Jan  1 10:00:03 server sshd[1234]: Accepted password for admin from 10.0.0.50 port 22 ssh2",
            "Jan  1 10:05:00 server sshd[1235]: Invalid user hacker from 203.0.113.5 port 22",
            "Jan  1 10:05:01 server sshd[1235]: Failed password for invalid user hacker from 203.0.113.5 port 22 ssh2",
            "Jan  1 10:10:00 server kernel: POSSIBLE BREAK-IN ATTEMPT from 203.0.113.5",
            "Jan  1 10:15:00 server webapp: SQL injection attempt detected from 198.51.100.10",
            "Jan  1 10:20:00 server firewall: port scan detected from 192.168.1.200",
            "Jan  1 10:25:00 server sshd[1236]: Failed password for user from 192.168.1.100 port 22 ssh2",
            "Jan  1 10:25:01 server sshd[1236]: Failed password for user from 192.168.1.100 port 22 ssh2",
            "Jan  1 10:25:02 server sshd[1236]: Failed password for user from 192.168.1.100 port 22 ssh2",
            "Jan  1 10:30:00 server sshd[1237]: Accepted password for backup from 10.0.0.75 port 22 ssh2"
        ]
        
        with open(self.log_file, 'w') as f:
            for log in sample_logs:
                f.write(log + '\n')
        
        print(f"✅ Fichier de logs créé : {self.log_file}")

# ===== EXÉCUTION DU PROGRAMME =====
if __name__ == "__main__":
    # Initialiser l'analyseur
    analyzer = SecurityLogAnalyzer("security.log")
    
    # Lancer l'analyse
    analyzer.analyze()
    
    # Suggestions pour l'amélioration
    print("\n💡 Suggestions d'amélioration :")
    print("1. Ajouter la détection de patterns personnalisés")
    print("2. Implémenter l'envoi d'alertes par email")
    print("3. Sauvegarder les résultats dans une base de données")
    print("4. Créer une interface web de monitoring")

Ce que fait ce script :

Lit et analyse les fichiers de logs système
Détecte les tentatives de connexion échouées
Identifie les scans de ports et attaques par force brute
Génère un rapport détaillé des menaces
Classe les IPs par niveau de menace

🎯 Exercice pratique :

Modifiez le script pour ajouter la détection des attaques XSS dans les logs web.

Scanner de Ports Avancé avec Multithreading

Un scanner de ports est l'outil fondamental de tout pentester. Cette version avancée utilise le multithreading pour scanner rapidement.

#!/usr/bin/env python3
"""
SCANNER DE PORTS AVANCÉ
Version : 2.0
Auteur : CyberCode
Description : Scanner multithreadé avec détection de service et export JSON
"""

import socket
import threading
import queue
import json
import time
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor, as_completed

class AdvancedPortScanner:
    """
    Scanner de ports professionnel avec multithreading et analyse de services
    """
    
    # Services courants et leurs ports
    COMMON_SERVICES = {
        20: "FTP-Data", 21: "FTP", 22: "SSH", 23: "Telnet",
        25: "SMTP", 53: "DNS", 80: "HTTP", 110: "POP3",
        143: "IMAP", 443: "HTTPS", 465: "SMTPS", 587: "SMTP-Submission",
        993: "IMAPS", 995: "POP3S", 3306: "MySQL", 3389: "RDP",
        5432: "PostgreSQL", 5900: "VNC", 6379: "Redis", 8080: "HTTP-Alt",
        8443: "HTTPS-Alt", 27017: "MongoDB", 9200: "Elasticsearch"
    }
    
    # Ports vulnérables connus
    VULNERABLE_PORTS = {
        21: "FTP - Vérifier l'anonymat",
        22: "SSH - Vérifier la version",
        23: "Telnet - Chiffrement non sécurisé",
        80: "HTTP - Rechercher vulnérabilités web",
        443: "HTTPS - Vérifier les certificats",
        3389: "RDP - Vérifier l'authentification",
        445: "SMB - Vérifier les partages",
        1433: "MSSQL - Vérifier l'authentification",
        3306: "MySQL - Vérifier les accès",
        5900: "VNC - Authentification faible"
    }
    
    def __init__(self, target, max_threads=100, timeout=1.0):
        """
        Initialise le scanner
        
        Args:
            target: Adresse IP ou hostname à scanner
            max_threads: Nombre maximum de threads simultanés
            timeout: Timeout de connexion en secondes
        """
        self.target = target
        self.max_threads = max_threads
        self.timeout = timeout
        self.open_ports = []
        self.results = []
        self.scan_stats = {
            'start_time': None,
            'end_time': None,
            'total_ports': 0,
            'scanned_ports': 0,
            'open_ports': 0,
            'closed_ports': 0,
            'filtered_ports': 0
        }
        
        # Configuration des sockets
        socket.setdefaulttimeout(timeout)
    
    def scan_port(self, port):
        """
        Scan un port unique avec détection de service
        
        Args:
            port: Numéro de port à scanner
        
        Returns:
            Tuple (port, status, service, banner)
        """
        try:
            # Création du socket
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            
            # Tentative de connexion
            result = sock.connect_ex((self.target, port))
            
            if result == 0:
                # Port ouvert - Récupération du banner
                service = self.COMMON_SERVICES.get(port, "unknown")
                banner = self.get_banner(sock)
                
                # Vérification de vulnérabilités connues
                vulnerability = self.VULNERABLE_PORTS.get(port)
                
                return {
                    'port': port,
                    'status': 'OPEN',
                    'service': service,
                    'banner': banner[:100] if banner else None,
                    'vulnerability': vulnerability,
                    'protocol': 'TCP'
                }
            else:
                return {
                    'port': port,
                    'status': 'CLOSED',
                    'service': None,
                    'banner': None,
                    'vulnerability': None,
                    'protocol': 'TCP'
                }
            
            sock.close()
            
        except socket.timeout:
            return {
                'port': port,
                'status': 'FILTERED',
                'service': None,
                'banner': None,
                'vulnerability': None,
                'protocol': 'TCP'
            }
        except Exception as e:
            return {
                'port': port,
                'status': 'ERROR',
                'service': None,
                'banner': None,
                'vulnerability': None,
                'protocol': 'TCP',
                'error': str(e)
            }
    
    def get_banner(self, sock):
        """
        Tente de récupérer le banner du service
        
        Args:
            sock: Socket connecté
        
        Returns:
            Banner du service ou None
        """
        try:
            # Envoi d'une requête basique pour certains services
            port = sock.getpeername()[1]
            
            if port == 80:
                sock.send(b"GET / HTTP/1.0\r\n\r\n")
            elif port == 22:
                sock.send(b"SSH-2.0-CyberScanner\r\n")
            elif port == 21:
                sock.send(b"USER anonymous\r\n")
            
            # Réception de la réponse
            banner = sock.recv(1024)
            return banner.decode('utf-8', errors='ignore').strip()
            
        except:
            return None
    
    def scan_range(self, start_port=1, end_port=1024):
        """
        Scan une plage de ports avec multithreading
        
        Args:
            start_port: Port de début
            end_port: Port de fin
        
        Returns:
            Liste des résultats
        """
        print(f"🚀 Démarrage du scan sur {self.target}")
        print(f"📡 Plage de ports: {start_port}-{end_port}")
        print(f"⚡ Threads: {self.max_threads}")
        print("=" * 60)
        
        self.scan_stats['start_time'] = datetime.now()
        self.scan_stats['total_ports'] = end_port - start_port + 1
        
        # Création de la queue des ports à scanner
        ports = list(range(start_port, end_port + 1))
        
        # Scanning avec ThreadPoolExecutor
        with ThreadPoolExecutor(max_workers=self.max_threads) as executor:
            # Soumettre tous les ports au scanner
            future_to_port = {
                executor.submit(self.scan_port, port): port 
                for port in ports
            }
            
            # Traitement des résultats au fur et à mesure
            for future in as_completed(future_to_port):
                port = future_to_port[future]
                self.scan_stats['scanned_ports'] += 1
                
                try:
                    result = future.result()
                    self.results.append(result)
                    
                    # Mise à jour des statistiques
                    if result['status'] == 'OPEN':
                        self.scan_stats['open_ports'] += 1
                        self.open_ports.append(port)
                        
                        # Affichage en temps réel
                        service = result['service'] or 'unknown'
                        print(f"✅ Port {port:5d} OUVERT - {service}")
                        
                        if result['vulnerability']:
                            print(f"   ⚠️  Vulnérabilité possible: {result['vulnerability']}")
                    
                    elif result['status'] == 'CLOSED':
                        self.scan_stats['closed_ports'] += 1
                    elif result['status'] == 'FILTERED':
                        self.scan_stats['filtered_ports'] += 1
                    
                    # Afficher la progression
                    if self.scan_stats['scanned_ports'] % 100 == 0:
                        progress = (self.scan_stats['scanned_ports'] / 
                                  self.scan_stats['total_ports']) * 100
                        print(f"📊 Progression: {progress:.1f}%")
                        
                except Exception as e:
                    print(f"❌ Erreur sur le port {port}: {e}")
        
        self.scan_stats['end_time'] = datetime.now()
        return self.results
    
    def generate_report(self, format='text'):
        """
        Génère un rapport du scan
        
        Args:
            format: Format du rapport ('text', 'json', 'html')
        """
        duration = self.scan_stats['end_time'] - self.scan_stats['start_time']
        
        if format == 'text':
            print("\n" + "=" * 60)
            print("📋 RAPPORT DU SCAN")
            print("=" * 60)
            
            print(f"🎯 Cible: {self.target}")
            print(f"⏱️  Durée: {duration}")
            print(f"🔢 Ports scannés: {self.scan_stats['scanned_ports']}")
            print(f"✅ Ports ouverts: {self.scan_stats['open_ports']}")
            print(f"❌ Ports fermés: {self.scan_stats['closed_ports']}")
            print(f"🛡️  Ports filtrés: {self.scan_stats['filtered_ports']}")
            
            if self.open_ports:
                print("\n📡 PORTS OUVERTS DÉTECTÉS:")
                print("-" * 40)
                
                for result in self.results:
                    if result['status'] == 'OPEN':
                        service = result['service'] or 'Inconnu'
                        banner = result['banner'] or 'Aucun banner'
                        vuln = result['vulnerability'] or 'Aucune vulnérabilité connue'
                        
                        print(f"Port {result['port']}:")
                        print(f"  Service: {service}")
                        print(f"  Banner: {banner[:50]}..." if len(banner) > 50 else f"  Banner: {banner}")
                        print(f"  Vulnérabilité: {vuln}")
                        print()
            
            # Recommandations de sécurité
            print("💡 RECOMMANDATIONS DE SÉCURITÉ:")
            print("-" * 40)
            
            if self.scan_stats['open_ports'] > 20:
                print("⚠️  Trop de ports ouverts - Réduisez l'exposition réseau")
            
            vulnerable_services = [r for r in self.results 
                                 if r['vulnerability'] and r['status'] == 'OPEN']
            if vulnerable_services:
                print("⚠️  Services vulnérables détectés:")
                for service in vulnerable_services:
                    print(f"  - Port {service['port']}: {service['vulnerability']}")
            
            print("\n🔒 Bonnes pratiques:")
            print("  • Fermez les ports inutilisés")
            print("  • Mettez à jour les services régulièrement")
            print("  • Utilisez des pare-feu et IPS")
            print("  • Auditez régulièrement votre réseau")
        
        elif format == 'json':
            report = {
                'target': self.target,
                'scan_date': datetime.now().isoformat(),
                'duration_seconds': duration.total_seconds(),
                'statistics': self.scan_stats,
                'open_ports': [r for r in self.results if r['status'] == 'OPEN'],
                'vulnerable_services': [r for r in self.results 
                                      if r['vulnerability'] and r['status'] == 'OPEN']
            }
            return json.dumps(report, indent=2, default=str)
    
    def save_results(self, filename="scan_results.json"):
        """
        Sauvegarde les résultats dans un fichier
        
        Args:
            filename: Nom du fichier de sortie
        """
        report = self.generate_report('json')
        
        with open(filename, 'w') as f:
            f.write(report)
        
        print(f"💾 Résultats sauvegardés dans {filename}")

# ===== EXÉCUTION PRINCIPALE =====
if __name__ == "__main__":
    import argparse
    
    # Configuration des arguments
    parser = argparse.ArgumentParser(description='Scanner de ports avancé')
    parser.add_argument('target', help='Adresse IP ou hostname à scanner')
    parser.add_argument('-s', '--start', type=int, default=1, 
                       help='Port de début (défaut: 1)')
    parser.add_argument('-e', '--end', type=int, default=1024,
                       help='Port de fin (défaut: 1024)')
    parser.add_argument('-t', '--threads', type=int, default=100,
                       help='Nombre de threads (défaut: 100)')
    parser.add_argument('-o', '--output', help='Fichier de sortie JSON')
    
    args = parser.parse_args()
    
    # Création et exécution du scanner
    scanner = AdvancedPortScanner(args.target, args.threads)
    
    try:
        # Exécution du scan
        scanner.scan_range(args.start, args.end)
        
        # Génération du rapport
        scanner.generate_report('text')
        
        # Sauvegarde si demandé
        if args.output:
            scanner.save_results(args.output)
    
    except KeyboardInterrupt:
        print("\n⏹️  Scan interrompu par l'utilisateur")
    
    except Exception as e:
        print(f"❌ Erreur: {e}")

# ===== EXEMPLE D'UTILISATION =====
# python port_scanner.py 192.168.1.1 -s 1 -e 1000 -t 200 -o scan.json
# python port_scanner.py scanme.nmap.org -s 20 -e 100

🎓 Points clés de cette leçon :

Multithreading : Scanner plusieurs ports simultanément
Détection de service : Identifier les services derrière les ports
Banner grabbing : Récupérer les informations des services
Gestion d'erreurs : Gérer les timeouts et erreurs réseau
Export de résultats : Générer des rapports JSON/text

Module 2 : Analyse Réseau & Sécurité

8 heures

Intermédiaire

0/6 complétés

Analyse de Paquets avec Scapy

Scapy est une bibliothèque Python puissante pour la manipulation de paquets réseau. Elle permet de créer, envoyer, capturer et analyser des paquets réseau.

Prérequis

Pour utiliser Scapy, installez-le avec : pip install scapy

#!/usr/bin/env python3
# LABORATOIRE DE SÉCURITÉ CYBERCODE
# Vous pouvez modifier et exécuter ce code directement

print("🔐 BIENVENUE DANS LE LAB CYBERSÉCURITÉ")
print("=" * 50)

# 1. Informations système
import platform
import datetime

print("📊 INFORMATIONS SYSTÈME")
print(f"  • OS: {platform.system()} {platform.release()}")
print(f"  • Architecture: {platform.machine()}")
print(f"  • Python: {platform.python_version()}")
print(f"  • Date: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

print("\n🔍 TEST DE SÉCURITÉ BASIQUE")

# 2. Vérification des ports locaux
import socket

def check_local_ports():
    """Vérifie les ports courants sur localhost"""
    common_ports = [
        (80, "HTTP"),
        (443, "HTTPS"),
        (22, "SSH"),
        (21, "FTP"),
        (3306, "MySQL"),
        (5432, "PostgreSQL"),
        (3389, "RDP"),
        (8080, "HTTP-Alt")
    ]
    
    print("  • Ports ouverts (localhost):")
    
    for port, service in common_ports:
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(0.5)
            result = sock.connect_ex(('127.0.0.1', port))
            
            if result == 0:
                print(f"    ✅ Port {port} ({service}) : OUVERT")
            else:
                print(f"    ❌ Port {port} ({service}) : fermé")
            
            sock.close()
            
        except Exception as e:
            print(f"    ⚠️  Port {port} : erreur ({e})")

# 3. Analyse de hash
import hashlib

def demo_hash():
    """Démonstration de fonctions de hachage"""
    print("\n🔒 FONCTIONS DE HACHAGE")
    
    test_data = b"CyberCode Security Demo"
    
    algorithms = ['md5', 'sha1', 'sha256', 'sha512']
    
    for algo in algorithms:
        hash_func = hashlib.new(algo)
        hash_func.update(test_data)
        digest = hash_func.hexdigest()
        print(f"  • {algo.upper():10} : {digest[:16]}...")

# 4. Générateur de mot de passe
import random
import string

def generate_password(length=16):
    """Génère un mot de passe sécurisé"""
    characters = string.ascii_letters + string.digits + "!@#$%^&*"
    password = ''.join(random.choice(characters) for _ in range(length))
    
    # Vérification de sécurité
    has_upper = any(c.isupper() for c in password)
    has_lower = any(c.islower() for c in password)
    has_digit = any(c.isdigit() for c in password)
    has_special = any(not c.isalnum() for c in password)
    
    security_score = sum([has_upper, has_lower, has_digit, has_special])
    
    return password, security_score

# Exécution des fonctions
if __name__ == "__main__":
    check_local_ports()
    demo_hash()
    
    print("\n🔑 GÉNÉRATION DE MOT DE PASSE")
    password, score = generate_password()
    print(f"  • Mot de passe généré : {password}")
    print(f"  • Score de sécurité : {score}/4")
    
    if score == 4:
        print("  ✅ Mot de passe TRÈS SÉCURISÉ")
    elif score >= 2:
        print("  ⚠️  Mot de passe MOYEN - Peut être amélioré")
    else:
        print("  ❌ Mot de passe FAIBLE - À changer immédiatement")
    
    print("\n" + "=" * 50)
    print("🎉 LABORATOIRE TERMINÉ AVEC SUCCÈS!")
    print("\n💡 Conseils:")
    print("  • Modifiez ce code pour explorer différentes fonctionnalités")
    print("  • Testez vos propres scripts de sécurité")
    print("  • Utilisez 'Modèle' pour charger des exemples avancés")

Terminal - Sortie du code

Le résultat s'affichera ici après exécution...

Cliquez sur "Exécuter" ou appuyez sur F5 pour démarrer.

Exercices Pratiques

45 exercices

12 complétés

Scanner de Vulnérabilités

Débutant

Créez un scanner qui vérifie les services vulnérables sur une machine cible. L'outil doit détecter les versions de services obsolètes et les configurations dangereuses.

📋 Exigences :

Scanner les ports 1-1000
Identifier les services (SSH, HTTP, FTP, etc.)
Vérifier les versions vulnérables
Générer un rapport JSON

Analyseur de Politique de Mots de Passe

Intermédiaire

Développez un outil qui vérifie si les mots de passe respectent une politique de sécurité d'entreprise. L'outil doit pouvoir analyser une liste de mots de passe et générer des statistiques.

📋 Exigences :

Vérifier la longueur (min 12 caractères)
Vérifier la complexité (majuscules, minuscules, chiffres, spéciaux)
Comparer avec les mots de passe compromis
Calculer un score de sécurité

Détecteur d'Intrusion Basique

Avancé

Implémentez un système simple de détection d'intrusion qui analyse le trafic réseau en temps réel et alerte sur les activités suspectes.

📋 Exigences :

Détecter les scans de ports
Identifier les attaques par force brute
Analyser les patterns de trafic
Générer des alertes en temps réel

Python Réseau Sécurité Nouveau

CyberScan Pro

Suite complète d'analyse de sécurité réseau avec scanner de ports avancé, détection de vulnérabilités, analyse de services et génération de rapports professionnels.

✨ Fonctionnalités :

Scanner multithreadé (1000+ ports/seconde)
Détection automatique de services
Analyse de vulnérabilités CVE
Génération de rapports PDF/HTML
Interface Web interactive

Python Logs Monitoring

LogGuardian

Système de monitoring et d'analyse de logs en temps réel avec détection d'anomalies, alertes intelligentes et tableaux de bord personnalisables.

✨ Fonctionnalités :

Analyse de logs en temps réel
Détection de patterns suspects
Alertes par email/SMS/Webhook
Tableaux de bord Grafana
Stockage et recherche avancée

Documentation & Références

Accédez à la documentation complète des outils et bibliothèques essentiels en cybersécurité.

Python Security Guide Network Protocols Cryptography Handbook OWASP Top 10

Tutoriels Vidéo

Des heures de tutoriels pratiques pour maîtriser chaque aspect de la cybersécurité.

Python pour Pentesters Réseaux et Sécurité Cryptographie Pratique Forensic Numérique

Outils & Logiciels

Téléchargez les outils essentiels pour pratiquer la cybersécurité en environnement contrôlé.

Kali Linux Metasploit Framework Wireshark Burp Suite

Challenges Capture The Flag (CTF)

Testez vos compétences avec ces challenges progressifs. Chaque niveau vous prépare aux certifications professionnelles.

Niveau Débutant

💻 Casseur de code César
🔍 Analyse de logs basique
🔐 Vérificateur de hash
📡 Scanner de ports simple
🔑 Générateur de mot de passe

Niveau Intermédiaire

🕵️‍♂️ Steganographie basique
🌐 Analyse web (robots.txt, headers)
📊 Analyse de trafic réseau
🔒 Cryptographie symétrique
📝 Injection SQL basique

Niveau Avancé

⚡ Buffer Overflow basique
🔓 Reverse engineering
🛡️ Bypass d'authentification
📡 Packet crafting avancé
🎯 Exploitation de services