Ce document décrit l'API publique de ZDefender, un système avancé de protection contre les attaques DDoS. Il est conçu pour être utilisé comme bibliothèque dans des applications Rust ou via une interface CLI.

• Introduction
• Modules principaux
• Structures de données
• API publique
  • ProtectionManager
    • Méthodes principales
  • PacketInfo
  • Actions
• Exemple d'utilisation
• Configuration
• Journalisation
• Support et assistance

L'API de ZDefender permet aux développeurs d'intégrer ses fonctionnalités de détection et de mitigation des attaques DDoS dans leurs propres applications. Elle expose des structures de données et des méthodes pour analyser le trafic réseau, appliquer des stratégies de protection et journaliser les événements.

Si vous rencontrez des problèmes lors de l'utilisation de l'API, consultez la section des problèmes connus ou ouvrez une discussion sur GitHub.

L'API est organisée en plusieurs modules, chacun correspondant à une responsabilité spécifique :

• models.rs: Définit les structures de données fondamentales.
• log_mode.rs: Gère les modes de journalisation (fichier ou systemd-journal).
• config.rs: Charge et valide la configuration du système.
• protection.rs: Coordonne les stratégies de protection.
• analyzer.rs: Analyse le trafic réseau en temps réel.
• packet_inspection.rs: Inspecte les paquets pour détecter des anomalies.
• detect_attacks.rs: Implémente les algorithmes de détection des attaques.
• defender.rs: Applique les actions de défense (blocage, limitation de débit, etc.).

Représente les informations extraites d'un paquet réseau.

pub struct PacketInfo {
    pub source_ip: String,
    pub destination_ip: String,
    pub protocol: String,
    pub packet_size: usize,
    pub timestamp: u64,
}

Enumération des actions possibles prises par le système.

pub enum Action {
    Drop, // Supprimer le paquet
    Block(String, Duration), // Bloquer une IP pendant une durée donnée
    RateLimit(String), // Limiter le débit pour une IP
    None, // Aucune action nécessaire
}

Pour plus de détails sur les actions, consultez la section Actions.

Le ProtectionManager est le point d'entrée principal pour interagir avec l'API de ZDefender. Il coordonne l'analyse du trafic, la détection des anomalies et les actions de défense.

La structure PacketInfo est utilisée pour représenter un paquet réseau analysé. Elle contient des informations essentielles telles que l'IP source, l'IP destination, le protocole et la taille du paquet.

Pour plus de détails, consultez la documentation complète.

Les actions possibles sont définies dans l'énumération Action. Elles incluent :

• Drop: Supprime immédiatement un paquet suspect.
• Block: Ajoute une IP à la liste noire pour une durée spécifiée.
• RateLimit: Limite le débit pour une IP donnée.
• None: Indique qu'aucune action n'est nécessaire.

Pour plus d'exemples d'utilisation des actions, consultez la section Exemple d'utilisation.

Voici un exemple d'intégration de ZDefender dans une application Rust :

use zdefender::{ProtectionManager, PacketInfo, Action, LogMode};
use std::sync::Arc;
use tokio::sync::{mpsc, RwLock};

#[tokio::main]
async fn main() {
    // Initialiser les canaux de communication
    let (report_tx, mut report_rx) = mpsc::channel(100);

    // Charger la configuration
    let config = Arc::new(RwLock::new(Config::default()));

    // Initialiser le gestionnaire de protection
    let mut protection = ProtectionManager::new(config, report_tx).await;

    // Configurer les seuils de détection
    protection.set_thresholds(1000.0, 0.8);

    // Simuler un paquet réseau
    let packet = PacketInfo {
        source_ip: "192.168.1.1".to_string(),
        destination_ip: "192.168.1.2".to_string(),
        protocol: "TCP".to_string(),
        packet_size: 64,
        timestamp: 1234567890,
    };

    // Traiter le paquet
    if let Some(action) = protection.process_packet(packet) {
        match action {
            Action::Drop => println!("Paquet supprimé."),
            Action::Block(ip, duration) => println!("IP {} bloquée pour {:?}", ip, duration),
            Action::RateLimit(ip) => println!("Limitation de débit pour l'IP {}", ip),
            Action::None => println!("Aucune action nécessaire."),
        }
    }
}

Pour plus d'exemples, consultez la section Utilisation dans le README.

La configuration de ZDefender est définie dans un fichier JSON. Les options principales incluent :

Pour plus de détails sur la configuration, consultez la section Configuration dans le README.

ZDefender prend en charge deux modes de journalisation :

• Fichier: Les logs sont écrits dans un fichier classique (/var/log/zdefender/zdefender.log par défaut).
• SystemdJournal: Les logs sont envoyés à systemd-journal.

Pour activer le support SystemdJournal, compilez le projet avec la feature systemd :

cargo build --release --features systemd

Ensuite, configurez le mode de journalisation dans le fichier JSON :

"log_mode": "SystemdJournal"

Pour plus d'informations sur la journalisation, consultez la section Journalisation dans le README.

Si vous rencontrez des problèmes ou avez des questions sur l'API, voici quelques ressources utiles :

• Discussions GitHub: Posez vos questions ou partagez vos idées ici.
• Issues GitHub: Signalez des bugs ou demandez des fonctionnalités.
• Documentation complète: Consultez le wiki pour des guides détaillés.