#!/bin/bash
#
# Script d'installation et configuration de rkhunter et ClamAV
# pour la détection de rootkits et malwares sur Debian 12
#
# Idempotent et professionnel
# Usage: sudo ./install_security_tools.sh

set -euo pipefail

# Couleurs pour l'output
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly NC='\033[0m'

# Constantes
readonly LOG_FILE="/var/log/security_tools_install.log"
readonly RKHUNTER_CONF="/etc/rkhunter.conf"
readonly RKHUNTER_LOCAL_CONF="/etc/rkhunter.conf.local"
readonly CLAMAV_CONF="/etc/clamav/clamd.conf"
readonly AIDE_CONF="/etc/aide/aide.conf"

#################################################################
# CONFIGURATION DES EXCEPTIONS - FAUX POSITIFS CONNUS
#################################################################
# Ajoutez ici les fichiers/commandes qui génèrent des faux positifs
# Format: un chemin complet par ligne
readonly RKHUNTER_EXCEPTIONS=(
    "/usr/bin/lwp-request"
    "/usr/bin/GET"
    "/usr/bin/HEAD"
    "/usr/bin/POST"
    "/usr/sbin/unhide"
    # Ajoutez vos propres exceptions ici
    # "/chemin/vers/votre/fichier"
)

# Vérifier les privilèges root en premier
if [[ $EUID -ne 0 ]]; then
    echo -e "${RED}ERREUR: Ce script doit être exécuté avec les privilèges root${NC}"
    echo -e "${YELLOW}Utilisation: sudo $0${NC}"
    exit 1
fi

# Fonction de logging
log() {
    echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $*" | tee -a "$LOG_FILE"
}

log_error() {
    echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] ERROR:${NC} $*" | tee -a "$LOG_FILE"
}

log_warning() {
    echo -e "${YELLOW}[$(date +'%Y-%m-%d %H:%M:%S')] WARNING:${NC} $*" | tee -a "$LOG_FILE"
}

# Vérifier les privilèges root
check_root() {
    if [[ $EUID -ne 0 ]]; then
        log_error "Ce script doit être exécuté en tant que root"
        exit 1
    fi
}

# Vérifier la distribution
check_distribution() {
    if [[ ! -f /etc/debian_version ]]; then
        log_error "Ce script est conçu pour Debian 12"
        exit 1
    fi
    
    local version
    version=$(cat /etc/debian_version | cut -d. -f1)
    if [[ "$version" != "12" ]]; then
        log_warning "Version Debian détectée: $version (recommandé: 12)"
    fi
}

# Mise à jour du système
update_system() {
    log "Mise à jour de la liste des paquets..."
    if ! apt-get update -qq; then
        log_error "Échec de la mise à jour des paquets"
        exit 1
    fi
}

# Installation de rkhunter
install_rkhunter() {
    log "Vérification de l'installation de rkhunter..."
    
    if command -v rkhunter &> /dev/null; then
        log "rkhunter est déjà installé ($(rkhunter --version | head -n1))"
        return 0
    fi
    
    log "Installation de rkhunter..."
    if ! apt-get install -y rkhunter; then
        log_error "Échec de l'installation de rkhunter"
        exit 1
    fi
    
    log "rkhunter installé avec succès"
}

# Configuration de rkhunter
configure_rkhunter() {
    log "Configuration de rkhunter..."
    
    # Backup du fichier de configuration original
    if [[ -f "$RKHUNTER_CONF" && ! -f "${RKHUNTER_CONF}.backup" ]]; then
        cp "$RKHUNTER_CONF" "${RKHUNTER_CONF}.backup"
        log "Backup de la configuration: ${RKHUNTER_CONF}.backup"
    fi
    
    # Configuration recommandée
    sed -i 's/^UPDATE_MIRRORS=.*/UPDATE_MIRRORS=1/' "$RKHUNTER_CONF"
    sed -i 's/^MIRRORS_MODE=.*/MIRRORS_MODE=0/' "$RKHUNTER_CONF"
    sed -i 's/^WEB_CMD=.*/WEB_CMD=""/' "$RKHUNTER_CONF"
    
    # Activer les mises à jour automatiques de la base de données
    if ! grep -q "^CRON_DAILY_RUN=" "$RKHUNTER_CONF"; then
        echo "CRON_DAILY_RUN=true" >> "$RKHUNTER_CONF"
    else
        sed -i 's/^CRON_DAILY_RUN=.*/CRON_DAILY_RUN=true/' "$RKHUNTER_CONF"
    fi
    
    if ! grep -q "^CRON_DB_UPDATE=" "$RKHUNTER_CONF"; then
        echo "CRON_DB_UPDATE=true" >> "$RKHUNTER_CONF"
    else
        sed -i 's/^CRON_DB_UPDATE=.*/CRON_DB_UPDATE=true/' "$RKHUNTER_CONF"
    fi
    
    log "Configuration de rkhunter terminée"
}

# Configurer les exceptions rkhunter (faux positifs)
configure_rkhunter_exceptions() {
    log "Configuration des exceptions rkhunter (faux positifs)..."
    
    # Créer ou vider le fichier local
    : > "$RKHUNTER_LOCAL_CONF"
    
    cat >> "$RKHUNTER_LOCAL_CONF" << 'EOF'
# Configuration locale rkhunter
# Fichier généré automatiquement - Exceptions pour faux positifs
# Date: $(date)

EOF
    
    local count=0
    for exception in "${RKHUNTER_EXCEPTIONS[@]}"; do
        # Vérifier si le fichier existe avant de l'ajouter
        if [[ -f "$exception" ]]; then
            echo "SCRIPTWHITELIST=\"$exception\"" >> "$RKHUNTER_LOCAL_CONF"
            log "Exception ajoutée: $exception"
            ((count++))
        else
            log_warning "Fichier non trouvé (exception ignorée): $exception"
        fi
    done
    
    log "$count exception(s) configurée(s) dans $RKHUNTER_LOCAL_CONF"
}

# Initialisation de rkhunter
initialize_rkhunter() {
    log "Mise à jour de la base de données rkhunter..."
    
    if ! rkhunter --update; then
        log_warning "Mise à jour de la base de données rkhunter échouée (peut nécessiter une connexion Internet)"
    fi
    
    log "Initialisation de la base de données des fichiers système..."
    if ! rkhunter --propupd; then
        log_error "Échec de l'initialisation de rkhunter"
        exit 1
    fi
    
    log "rkhunter initialisé avec succès"
}

# Installation de ClamAV
install_clamav() {
    log "Vérification de l'installation de ClamAV..."
    
    if command -v clamscan &> /dev/null; then
        log "ClamAV est déjà installé ($(clamscan --version))"
        return 0
    fi
    
    log "Installation de ClamAV et ClamAV Daemon..."
    if ! apt-get install -y clamav clamav-daemon clamav-freshclam; then
        log_error "Échec de l'installation de ClamAV"
        exit 1
    fi
    
    log "ClamAV installé avec succès"
}

# Configuration de ClamAV
configure_clamav() {
    log "Configuration de ClamAV..."
    
    # Arrêter les services pour la configuration
    systemctl stop clamav-freshclam 2>/dev/null || true
    
    # Mise à jour de la base de données virale
    log "Mise à jour de la base de données antivirale (cela peut prendre plusieurs minutes)..."
    if ! freshclam; then
        log_warning "Première mise à jour freshclam échouée, nouvelle tentative..."
        sleep 5
        freshclam || log_warning "Mise à jour freshclam échouée"
    fi
    
    # Activer et démarrer les services
    systemctl enable clamav-freshclam
    systemctl start clamav-freshclam
    
    log "Configuration de ClamAV terminée"
}

# Installation de AIDE
install_aide() {
    log "Vérification de l'installation de AIDE..."
    
    if command -v aide &> /dev/null; then
        log "AIDE est déjà installé ($(aide --version 2>&1 | head -n1))"
        return 0
    fi
    
    log "Installation de AIDE (Advanced Intrusion Detection Environment)..."
    if ! apt-get install -y aide aide-common; then
        log_error "Échec de l'installation de AIDE"
        exit 1
    fi
    
    log "AIDE installé avec succès"
}

# Configuration de AIDE
configure_aide() {
    log "Configuration de AIDE..."
    
    # Backup de la configuration originale
    if [[ -f "$AIDE_CONF" && ! -f "${AIDE_CONF}.backup" ]]; then
        cp "$AIDE_CONF" "${AIDE_CONF}.backup"
        log "Backup de la configuration AIDE: ${AIDE_CONF}.backup"
    fi
    
    # Vérifier si la base de données existe
    if [[ ! -f /var/lib/aide/aide.db ]]; then
        log "Initialisation de la base de données AIDE (cela peut prendre 10-30 minutes)..."
        log_warning "Cette opération est longue lors de la première exécution..."
        
        if ! aideinit; then
            log_error "Échec de l'initialisation de AIDE"
            exit 1
        fi
        
        # Copier la nouvelle base en tant que base active
        if [[ -f /var/lib/aide/aide.db.new ]]; then
            cp /var/lib/aide/aide.db.new /var/lib/aide/aide.db
            log "Base de données AIDE initialisée avec succès"
        fi
    else
        log "Base de données AIDE déjà existante"
    fi
    
    log "Configuration de AIDE terminée"
}

# Créer un script de vérification AIDE
create_aide_check_script() {
    log "Création du script de vérification AIDE..."
    
    local aide_script="/usr/local/bin/aide-check.sh"
    
    cat > "$aide_script" << 'EOF'
#!/bin/bash
# Script de vérification AIDE
# Généré automatiquement

LOGFILE="/var/log/aide-check-$(date +%Y%m%d).log"
MAILTO="root"

echo "=== Vérification AIDE du $(date) ===" > "$LOGFILE"

# Vérifier l'intégrité du système
aide --check >> "$LOGFILE" 2>&1

# Envoyer un email si des changements sont détectés
if grep -qE "changed|added|removed" "$LOGFILE"; then
    echo "Des changements de fichiers ont été détectés. Consultez $LOGFILE" | \
        mail -s "Alerte AIDE: $(hostname)" "$MAILTO"
fi

echo -e "\n=== Vérification terminée ===" >> "$LOGFILE"

# Mettre à jour la base de données après vérification (optionnel)
# Décommenter la ligne suivante pour mettre à jour automatiquement
# aide --update && cp /var/lib/aide/aide.db.new /var/lib/aide/aide.db
EOF

    chmod +x "$aide_script"
    log "Script de vérification AIDE créé: $aide_script"
}

# Créer un script de scan quotidien
create_daily_scan_script() {
    log "Création du script de scan quotidien..."
    
    local scan_script="/usr/local/bin/daily-security-scan.sh"
    
    cat > "$scan_script" << 'EOF'
#!/bin/bash
# Script de scan quotidien de sécurité
# Généré automatiquement

LOGFILE="/var/log/security-scan-$(date +%Y%m%d).log"
MAILTO="root"

echo "=== Scan de sécurité du $(date) ===" > "$LOGFILE"

# Scan rkhunter
echo -e "\n--- Scan rkhunter ---" >> "$LOGFILE"
rkhunter --check --skip-keypress --report-warnings-only >> "$LOGFILE" 2>&1

# Scan ClamAV des répertoires critiques
echo -e "\n--- Scan ClamAV ---" >> "$LOGFILE"
clamscan -r -i --exclude-dir="^/sys" --exclude-dir="^/proc" --exclude-dir="^/dev" \
    /home /root /tmp /var/www 2>&1 | tee -a "$LOGFILE"

# Envoyer un email si des problèmes sont détectés
if grep -qiE "warning|infected|rootkit" "$LOGFILE"; then
    echo "Des problèmes de sécurité ont été détectés. Consultez $LOGFILE" | \
        mail -s "Alerte sécurité: $(hostname)" "$MAILTO"
fi

echo -e "\n=== Scan terminé ===" >> "$LOGFILE"
EOF

    chmod +x "$scan_script"
    log "Script de scan créé: $scan_script"
}

# Configurer le cron pour les scans quotidiens
setup_cron() {
    log "Configuration des tâches cron..."
    
    local cron_file="/etc/cron.d/security-scan"
    
    cat > "$cron_file" << EOF
# Scan de sécurité quotidien
SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

# Scan quotidien à 2h du matin
0 2 * * * root /usr/local/bin/daily-security-scan.sh

# Scan quotidien à 13h (milieu de journée)
0 13 * * * root /usr/local/bin/daily-security-scan.sh

# Vérification AIDE hebdomadaire (dimanche à 3h)
0 3 * * 0 root /usr/local/bin/aide-check.sh

# Mise à jour rkhunter hebdomadaire
30 3 * * 0 root /usr/bin/rkhunter --update --quiet && /usr/bin/rkhunter --propupd

# Mise à jour base de données AIDE mensuelle (1er du mois à 4h)
0 4 1 * * root /usr/bin/aide --update && cp /var/lib/aide/aide.db.new /var/lib/aide/aide.db

# Mise à jour ClamAV (freshclam gère déjà cela via systemd)
EOF

    chmod 644 "$cron_file"
    log "Tâches cron configurées: $cron_file"
}

# Exécuter un premier scan
run_initial_scan() {
    log "Exécution d'un scan initial (cela peut prendre du temps)..."
    
    log "Scan rkhunter..."
    if rkhunter --check --skip-keypress --report-warnings-only; then
        log "Scan rkhunter terminé avec succès"
    else
        log_warning "Scan rkhunter terminé avec des avertissements (consultez /var/log/rkhunter.log)"
    fi
}

# Afficher les informations finales
print_summary() {
    cat << EOF

${GREEN}╔═══════════════════════════════════════════════════════════════╗
║         Installation terminée avec succès!                     ║
╚═══════════════════════════════════════════════════════════════╝${NC}

${YELLOW}Outils installés:${NC}
  • rkhunter: $(rkhunter --version | head -n1)
  • ClamAV: $(clamscan --version)
  • AIDE: $(aide --version 2>&1 | head -n1)

${YELLOW}Commandes utiles:${NC}
  ${GREEN}rkhunter:${NC}
    • Scan manuel:           sudo rkhunter --check
    • Mise à jour DB:        sudo rkhunter --update
    • Mise à jour proplist:  sudo rkhunter --propupd
  
  ${GREEN}ClamAV:${NC}
    • Scan manuel:           sudo clamscan -r /chemin
    • Mise à jour:           sudo freshclam
  
  ${GREEN}AIDE:${NC}
    • Vérifier intégrité:    sudo aide --check
    • Mettre à jour DB:      sudo aide --update
    • Initialiser DB:        sudo aideinit

${YELLOW}Fichiers de configuration:${NC}
  • rkhunter principal:    $RKHUNTER_CONF
  • rkhunter exceptions:   $RKHUNTER_LOCAL_CONF
  • AIDE config:           $AIDE_CONF
  
${YELLOW}Logs:${NC}
  • Installation:          $LOG_FILE
  • rkhunter:             /var/log/rkhunter.log
  • AIDE checks:          /var/log/aide-check-*.log
  • Scans quotidiens:     /var/log/security-scan-*.log

${YELLOW}Automatisation:${NC}
  • Scan quotidien:       2h00 et 13h00
  • Vérif AIDE:          Dimanche 3h00
  • MAJ rkhunter:        Dimanche 3h30
  • MAJ AIDE DB:         1er du mois 4h00

${YELLOW}Scripts créés:${NC}
  • /usr/local/bin/daily-security-scan.sh
  • /usr/local/bin/aide-check.sh

${GREEN}Le système est maintenant protégé avec une détection multicouche:${NC}
  ✓ Rootkits et backdoors (rkhunter)
  ✓ Malwares et virus (ClamAV)
  ✓ Intégrité des fichiers (AIDE)

${YELLOW}Note:${NC} Pour ajouter des exceptions rkhunter, éditez le script
      et ajoutez les chemins dans le tableau RKHUNTER_EXCEPTIONS,
      puis relancez le script.

EOF
}

# Fonction principale
main() {
    log "=== Démarrage de l'installation des outils de sécurité ==="
    
    check_root
    check_distribution
    update_system
    
    install_rkhunter
    configure_rkhunter
    configure_rkhunter_exceptions
    initialize_rkhunter
    
    install_clamav
    configure_clamav
    
    install_aide
    configure_aide
    
    create_daily_scan_script
    create_aide_check_script
    setup_cron
    
    run_initial_scan
    
    log "=== Installation terminée ==="
    print_summary
}

# Exécution
main "$@"