AUR compromis : Sécurisez votre Arch avec un script d’audit

#!/usr/bin/env python3
"""
Audit de sécurité anti-malware AUR (campagne Atomic Arch).
Vérifie la présence d'indicateurs de compromission (IoC) liés à 'atomic-lockfile'
et ses variantes (js-digest, lockfile-js, nextfile-js).
"""

import os
import subprocess
import sys

# Couleurs pour le terminal
GREEN = "\033[92m"
RED = "\033[91m"
YELLOW = "\033[93m"
BLUE = "\033[94m"
RESET = "\033[0m"


def print_status(message, status="info"):
    """Affiche un message d'état coloré selon la sévérité."""
    if status == "ok":
        print(f"[{GREEN}OK{RESET}] {message}")
    elif status == "warn":
        print(f"[{YELLOW}ATTENTION{RESET}] {message}")
    elif status == "danger":
        print(f"[{RED}DANGER{RESET}] {message}")
    else:
        print(f"[{BLUE}INFO{RESET}] {message}")


def check_root():
    """S'assure que le script est lancé avec les privilèges root pour bpftool et systemd."""
    if os.geteuid() != 0:
        print(f"{RED}Erreur : Ce script doit être exécuté avec sudo pour analyser le système.{RESET}")
        sys.exit(1)


def check_pacman_logs():
    """Cherche des traces d'infection dans les paquets pacman installés."""
    print_status("Analyse des métadonnées pacman (/var/lib/pacman/local/)...")
    target_path = "/var/lib/pacman/local/"
    found_malicious = False

    if not os.path.exists(target_path):
        print_status("Chemin pacman local introuvable. Es-tu bien sur Arch Linux ?", "warn")
        return

    suspect_keywords = ["atomic-lockfile", "js-digest", "lockfile-js", "nextfile-js"]
    for root, dirs, files in os.walk(target_path):
        for file in files:
            # On cible uniquement les métadonnées textuelles pour optimiser la recherche
            if file not in ("desc", "files", "install"):
                continue
            file_path = os.path.join(root, file)
            try:
                with open(file_path, "r", errors="ignore") as f:
                    content = f.read()
                    for kw in suspect_keywords:
                        if kw in content:
                            print_status(f"Alerte ! Signature '{kw}' trouvée : {file_path}", "danger")
                            found_malicious = True
            except Exception:
                continue

    if not found_malicious:
        print_status("Aucune trace de malware détectée dans les paquets installés.", "ok")


def check_aur_caches():
    """Vérifie si les caches d'assistants AUR contiennent des fichiers ou scripts suspects."""
    print_status("Analyse des caches d'assistants AUR (yay, paru) dans /home...")
    suspect_keywords = ["atomic-lockfile", "js-digest", "lockfile-js", "nextfile-js"]
    found_signature = False

    if not os.path.exists("/home"):
        return

    for user_dir in os.listdir("/home"):
        user_home = os.path.join("/home", user_dir)
        paths_to_check = [
            os.path.join(user_home, ".cache/yay"),
            os.path.join(user_home, ".cache/paru/clone")
        ]
        for base_path in paths_to_check:
            if not os.path.exists(base_path):
                continue
            for root, dirs, files in os.walk(base_path):
                for file in files:
                    if file == "PKGBUILD" or file.endswith(".install") or file.endswith(".js"):
                        file_path = os.path.join(root, file)
                        try:
                            with open(file_path, "r", errors="ignore") as f:
                                content = f.read()
                            for kw in suspect_keywords:
                                if kw in content:
                                    print_status(f"Signature '{kw}' détectée dans : {file_path}", "warn")
                                    found_signature = True
                        except Exception:
                            continue

    if not found_signature:
        print_status("Aucune trace suspecte dans les caches AUR.", "ok")


def check_ebpf():
    """Vérifie si des programmes eBPF suspects (type hook système) sont actifs."""
    print_status("Analyse des programmes eBPF actifs...")
    try:
        result = subprocess.run(
            ["bpftool", "prog", "list"], capture_output=True, text=True, check=True
        )
        output = result.stdout
        suspect_keywords = ["getdents", "sys_enter_write", "sys_enter_read"]
        found_suspect = False

        for line in output.splitlines():
            if any(kw in line.lower() for kw in suspect_keywords):
                print_status(f"Programme eBPF suspect détecté : {line.strip()}", "warn")
                found_suspect = True

        if not found_suspect:
            print_status("Aucun programme eBPF suspect détecté.", "ok")

    except FileNotFoundError:
        print_status("bpftool n'est pas installé. Analyse eBPF ignorée.", "warn")
        print("        -> Installation conseillée : sudo pacman -S bpftool")
    except subprocess.CalledProcessError as e:
        print_status(f"Erreur lors de l'exécution de bpftool : {e}", "warn")


def check_bpf_pinned_maps():
    """Vérifie la présence de cartes eBPF épinglées suspectes dans /sys/fs/bpf/."""
    print_status("Analyse des cartes eBPF épinglées (/sys/fs/bpf/)...")
    bpf_path = "/sys/fs/bpf"
    if not os.path.exists(bpf_path):
        print_status("Répertoire /sys/fs/bpf/ introuvable.", "warn")
        return

    found_pinned = []
    try:
        for root, dirs, files in os.walk(bpf_path):
            for file in files:
                file_path = os.path.join(root, file)
                if "/sys/fs/bpf/systemd" in file_path:
                    continue
                found_pinned.append(file_path)
    except Exception as e:
        print_status(f"Impossible de lire {bpf_path} : {e}", "warn")

    if found_pinned:
        for path in found_pinned:
            print_status(f"Carte eBPF épinglée détectée : {path}", "danger")
        print_status("Cartes eBPF suspectes détectées en dehors de systemd. Risque de rootkit !", "danger")
    else:
        print_status("Aucune carte eBPF suspecte détectée dans /sys/fs/bpf/.", "ok")


def check_tmp_directories():
    """Vérifie la présence de fichiers ou dossiers suspects dans /tmp et /var/tmp."""
    print_status("Analyse des dossiers temporaires (/tmp et /var/tmp)...")
    suspects = ["node_modules", "atomic-lockfile", "js-digest", "lockfile-js", "nextfile-js"]
    found = False

    for tmp_dir in ["/tmp", "/var/tmp"]:
        if not os.path.exists(tmp_dir):
            continue
        try:
            for item in os.listdir(tmp_dir):
                if any(s in item for s in suspects):
                    print_status(f"Fichier/Dossier suspect trouvé dans {tmp_dir} : {item}", "warn")
                    found = True
        except Exception as e:
            print_status(f"Impossible de lire {tmp_dir} : {e}", "warn")

    if not found:
        print_status("Les répertoires temporaires semblent propres.", "ok")


def check_systemd_persistence():
    """Analyse les services systemd système et utilisateur pour détecter une persistance."""
    print_status("Analyse des services systemd (système et utilisateur)...")
    suspect_paths = ["/tmp", "/var/tmp", "/dev/shm"]
    suspect_keywords = ["atomic-lockfile", "js-digest", "lockfile-js", "nextfile-js", "/deps"]
    search_dirs = ["/etc/systemd/system"]

    if os.path.exists("/home"):
        for user_dir in os.listdir("/home"):
            user_systemd = os.path.join("/home", user_dir, ".config/systemd/user")
            if os.path.exists(user_systemd):
                search_dirs.append(user_systemd)
    if os.path.exists("/root/.config/systemd/user"):
        search_dirs.append("/root/.config/systemd/user")

    found_suspicious = False
    for directory in search_dirs:
        try:
            for item in os.listdir(directory):
                if not item.endswith(".service"):
                    continue
                file_path = os.path.join(directory, item)
                try:
                    with open(os.path.realpath(file_path), "r", errors="ignore") as f:
                        content = f.read()

                    is_suspicious = False
                    reason = ""
                    exec_lines = [l for l in content.splitlines() if l.strip().startswith("ExecStart")]
                    for line in exec_lines:
                        if any(sp in line for sp in suspect_paths):
                            is_suspicious, reason = True, f"Exécute depuis un dossier temporaire ({line.strip()})"
                            break
                        if "/deps" in line or line.strip().endswith("deps") or "deps " in line:
                            is_suspicious, reason = True, f"Exécute un binaire nommé 'deps' suspect ({line.strip()})"
                            break

                    for kw in suspect_keywords:
                        if kw in content:
                            is_suspicious, reason = True, f"Contient la signature '{kw}'"
                            break

                    if is_suspicious:
                        print_status(f"Service suspect détecté : {file_path}", "danger")
                        print(f"        -> Motif : {reason}")
                        found_suspicious = True
                except Exception:
                    continue
        except Exception:
            continue

    if not found_suspicious:
        print_status("Aucun service systemd suspect détecté.", "ok")


def main():
    """Point d'entrée principal pour l'exécution séquentielle de l'audit."""
    print(f"{BLUE}=== AUDIT DE SÉCURITÉ ANTI-MALWARE AUR (ATOMIC ARCH) ==={RESET}\n")
    check_root()
    print("-" * 50)
    check_pacman_logs()
    print("-" * 50)
    check_aur_caches()
    print("-" * 50)
    check_ebpf()
    print("-" * 50)
    check_bpf_pinned_maps()
    print("-" * 50)
    check_tmp_directories()
    print("-" * 50)
    check_systemd_persistence()
    print("-" * 50)
    print(f"\n{BLUE}Audit terminé.{RESET}")


if __name__ == "__main__":
    main()