#!/usr/bin/python3
"""Service AuxiNuxOS Shield (auxinux-shield.service, root) : lance clamonacc (protection en temps réel par
fanotify, fichiers infectés bloqués), lit son journal, enregistre chaque menace bloquée pour l'administrateur et
pour le propriétaire du fichier (notification dans sa session), et vérifie que le blocage fonctionne vraiment :
un fichier de test EICAR, écrit par root (non analysé), est ouvert par un utilisateur ordinaire ; l'ouverture
doit être refusée (EPERM). SIGUSR1 relance cette vérification ; elle est aussi refaite toutes les 6 heures, et
clamd est interrogé (PING) toutes les 30 secondes : s'il ne répond plus, l'état passe en erreur jusqu'à ce qu'il
réponde et qu'une nouvelle vérification réussisse."""
import os
import shutil
import signal
import socket
import subprocess
import sys
import threading
import time
from pathlib import Path

sys.path.insert(0, os.environ.get("AUXINUX_SHELL_PYTHON", "/usr/share/auxinux-shell/python"))
from auxinux_shell.services import activation, shield  # noqa: E402

PATH = os.environ.get("AUXINUX_SHIELD_PATH", "/usr/sbin:/usr/bin:/sbin:/bin")
NOBODY = 65534
VERIFY_SECONDS = int(os.environ.get("AUXINUX_SHIELD_VERIFY_SECONDS", "90"))
LOG_MAX = 5 * 1024 * 1024
HEALTH_SECONDS = 30
REVERIFY_SECONDS = 6 * 3600


def say(text):
    print(text, flush=True)


class Monitor:
    def __init__(self):
        self.paths = shield.load_config()["paths"]
        self.process = None
        self.stopping = False
        self.ready = threading.Event()
        self.lock = threading.Lock()
        self.selftest_dir = None
        self.verifying = False
        self.homes = shield.human_homes()
        self.last_lines = []
        self.fatal = None            # raison précise d'un arrêt (fanotify refusé…)
        self.status_fields = {"pid": os.getpid(), "paths": self.paths, "verified": None}

    def status(self, state, **fields):
        with self.lock:
            self.status_fields.update(fields)
            shield.write_status(state, **self.status_fields)

    # ---------- Vérification réelle du blocage ----------

    def prepare_selftest(self):
        """Dossier de vérification créé AVANT clamonacc (déjà surveillé quand il démarre). Le dossier surveillé
        peut appartenir à l'utilisateur : rien n'y suit de lien symbolique (attaque contre root)."""
        self.selftest_dir = None
        for base in self.paths:
            try:
                parent = os.open(base, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
            except OSError:
                continue
            try:
                self._remove_selftest(parent)
                os.mkdir(shield.SELFTEST_NAME, 0o755, dir_fd=parent)
                os.chmod(shield.SELFTEST_NAME, 0o755, dir_fd=parent, follow_symlinks=False)
            except OSError as e:
                say(f"Dossier de vérification impossible dans {base} : {e}")
                os.close(parent)
                continue
            os.close(parent)
            self.selftest_dir = Path(base) / shield.SELFTEST_NAME
            return

    @staticmethod
    def _remove_selftest(parent_fd):
        """Supprime un ancien dossier de vérification (ou ce qui a pris son nom) sans suivre de lien."""
        try:
            info = os.stat(shield.SELFTEST_NAME, dir_fd=parent_fd, follow_symlinks=False)
        except FileNotFoundError:
            return
        import stat
        if not stat.S_ISDIR(info.st_mode):
            os.unlink(shield.SELFTEST_NAME, dir_fd=parent_fd)
            return
        folder = os.open(shield.SELFTEST_NAME, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=parent_fd)
        try:
            for name in os.listdir(folder):
                try:
                    os.unlink(name, dir_fd=folder)
                except IsADirectoryError:
                    shutil.rmtree(name, dir_fd=folder)
        finally:
            os.close(folder)
        os.rmdir(shield.SELFTEST_NAME, dir_fd=parent_fd)

    def _open_selftest_dir(self):
        """Descripteur du dossier de vérification, vérifié : au service (root), pas un lien."""
        parent = os.open(self.selftest_dir.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
        try:
            folder = os.open(shield.SELFTEST_NAME, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=parent)
        finally:
            os.close(parent)
        if os.fstat(folder).st_uid != os.geteuid():
            os.close(folder)
            raise OSError("dossier de vérification remplacé")
        return folder

    def reader_uid(self):
        """Utilisateur qui ouvrira le fichier de test : propriétaire du dossier surveillé (s'il n'est pas root),
        sinon nobody. root et clamav sont exclus de l'analyse : ils ne prouveraient rien."""
        try:
            uid = os.stat(self.selftest_dir.parent).st_uid
        except OSError:
            uid = 0
        return uid if uid not in (0,) else NOBODY

    READER = ("import errno, sys\n"
              "try:\n"
              "    open(sys.argv[1], 'rb').read(68)\n"
              "except PermissionError as e:\n"
              "    sys.exit(1 if e.errno == errno.EPERM else 2)\n"
              "except OSError:\n"
              "    sys.exit(2)\n")

    def open_as(self, uid, path):
        """Ouvre path en tant que uid : 0 lisible, 1 ouverture refusée (EPERM, blocage fanotify), 2 autre erreur,
        3 impossible de prendre l'identité de uid (la vérification ne prouverait rien)."""
        gid = NOBODY if uid == NOBODY else os.stat(self.selftest_dir.parent).st_gid
        try:
            result = subprocess.run([sys.executable, "-I", "-c", self.READER, path], user=uid, group=gid,
                                    extra_groups=[], cwd="/", env={"PATH": PATH}, timeout=60,
                                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        except (OSError, ValueError, subprocess.SubprocessError):
            return 3
        return result.returncode if result.returncode in (0, 1, 2) else 2

    def verify(self):
        if self.verifying:
            return
        self.verifying = True
        try:
            self._verify()
        finally:
            self.verifying = False

    def _verify(self):
        if self.selftest_dir is None or not self.selftest_dir.is_dir():
            self.prepare_selftest()
        if self.selftest_dir is None:
            self.status("error", error="Aucun dossier surveillé n'existe.", verified=None)
            return
        self.status("starting", error=None)
        name = "eicar-auxinux-shield.com"
        try:
            folder = self._open_selftest_dir()
        except OSError as e:
            self.status("error", verified=None, error=f"Vérification impossible : {e}")
            return
        try:
            try:
                os.unlink(name, dir_fd=folder)
            except FileNotFoundError:
                pass
            fd = os.open(name, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o644, dir_fd=folder)
            with os.fdopen(fd, "w") as f:
                f.write(shield.EICAR)
            os.chmod(name, 0o644, dir_fd=folder, follow_symlinks=False)
        except OSError as e:
            os.close(folder)
            self.status("error", verified=None, error=f"Vérification impossible : {e}")
            return
        test = str(self.selftest_dir / name)
        control = "temoin-propre.txt"
        try:
            fd = os.open(control, os.O_WRONLY | os.O_CREAT | os.O_TRUNC | os.O_NOFOLLOW, 0o644, dir_fd=folder)
            with os.fdopen(fd, "w") as f:
                f.write("AuxiNuxOS Shield : fichier témoin sans danger.\n")
            os.chmod(control, 0o644, dir_fd=folder, follow_symlinks=False)
        except OSError:
            pass
        uid = self.reader_uid()
        # Témoin : le même utilisateur doit pouvoir ouvrir un fichier propre au même endroit ; sinon un refus du
        # fichier EICAR ne viendrait pas forcément de l'antivirus.
        witness = self.open_as(uid, str(self.selftest_dir / control))
        if witness != 0:
            for item in (name, control):
                try:
                    os.unlink(item, dir_fd=folder)
                except OSError:
                    pass
            os.close(folder)
            say(f"Vérification non concluante : le fichier témoin n'a pas pu être lu (code {witness}).")
            self.status("error", verified=None, error="Vérification impossible : un utilisateur ordinaire ne peut "
                        "pas lire le fichier témoin dans le dossier surveillé.")
            return
        result = None
        deadline = time.monotonic() + VERIFY_SECONDS
        try:
            while time.monotonic() < deadline and not self.stopping:
                result = self.open_as(uid, test)
                if result == 1:
                    break
                time.sleep(2)
        finally:
            for item in (name, control):
                try:
                    os.unlink(item, dir_fd=folder)
                except OSError:
                    pass
            os.close(folder)
        if result == 1:
            say("Vérification réussie : le fichier de test EICAR est bloqué.")
            self.status("protected", verified=shield.now_iso(), error=None)
        elif not self.stopping:
            reason = ("le fichier de test EICAR reste lisible : la protection ne bloque pas" if result == 0 else
                      "le fichier de test n'a pas pu être ouvert pour la vérification")
            say("Vérification échouée : " + reason)
            self.status("error", verified=None, error=reason[0].upper() + reason[1:] + ".")

    # ---------- Journal de clamonacc ----------

    def handle_line(self, line):
        line = line.rstrip("\n")
        if not line.strip():
            return
        self.last_lines = (self.last_lines + [line])[-5:]
        found = shield.parse_found(line)
        if found is None:
            if "fanotify_init failed" in line or "can't setup fanotify" in line:
                self.fatal = ("fanotify indisponible : le noyau refuse la surveillance en temps réel (" +
                              line.rsplit(":", 1)[-1].strip() + ").")
                self.status("error", verified=None, error=self.fatal)
            if "starting fanotify event loop" in line:
                self.ready.set()
            return
        path, threat = found
        if self.selftest_dir is not None and path.startswith(str(self.selftest_dir) + "/"):
            return      # fichier de vérification
        uid = shield.owner_of(path, self.homes)
        event = {"time": shield.now_iso(), "path": path, "threat": threat, "action": "blocked", "uid": uid}
        say(f"Menace bloquée : {threat} dans {path}")
        try:
            shield.append_event(event, uid)
        except OSError as e:
            say(f"Détection non enregistrée : {e}")

    def follow_log(self):
        """Lit les nouvelles lignes du journal de clamonacc (fichier ouvert en ajout par clamonacc)."""
        position = self.log_start      # mesuré avant le lancement de clamonacc : aucune ligne perdue
        pending = ""
        while not self.stopping:
            try:
                size = shield.LOG_FILE.stat().st_size
            except OSError:
                size = 0
            if size < position:
                position = 0
            if size > position:
                with open(shield.LOG_FILE, encoding="utf-8", errors="replace") as f:
                    f.seek(position)
                    data = f.read()
                    position = f.tell()
                pending += data
                *lines, pending = pending.split("\n")
                for line in lines:
                    self.handle_line(line)
            if self.process is not None and self.process.poll() is not None:
                return
            time.sleep(0.4)

    def rotate_log(self):
        shield.LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
        try:
            if shield.LOG_FILE.stat().st_size > LOG_MAX:
                os.replace(shield.LOG_FILE, shield.LOG_FILE.with_name(shield.LOG_FILE.name + ".1"))
        except OSError:
            pass
        shield.LOG_FILE.touch(mode=0o640)

    # ---------- Cycle de vie ----------

    def run(self):
        if not activation.entitled("shield"):
            say("AuxiNuxOS Shield fait partie du mode PRO : ce PC n'y a pas droit.")
            self.status("unentitled", error="AuxiNuxOS Shield fait partie du mode PRO.")
            return 0
        clamonacc = shutil.which("clamonacc", path=PATH)
        if clamonacc is None or not shield.CLAMONACC_CONF.exists():
            self.status("error", error="clamonacc ou sa configuration est absent.")
            return 1
        self.status("starting", error=None)
        self.rotate_log()
        self.log_start = shield.LOG_FILE.stat().st_size
        self.prepare_selftest()
        argv = [clamonacc, "--foreground", "--fdpass", f"--config-file={shield.CLAMONACC_CONF}",
                f"--log={shield.LOG_FILE}", "--ping=60:2", "--wait"]
        say("Démarrage : " + " ".join(argv))
        self.process = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
                                        env={"PATH": PATH, "LC_ALL": "C.UTF-8"})
        threading.Thread(target=self._read_stdout, daemon=True).start()
        threading.Thread(target=self._verify_when_ready, daemon=True).start()
        threading.Thread(target=self._health, daemon=True).start()
        self.follow_log()
        code = self.process.wait()
        self.cleanup()
        if self.stopping:
            self.status("stopped", verified=None, error=None)
            return 0
        reason = next((line for line in reversed(self.last_lines) if line.strip()), f"code {code}")
        self.status("error", verified=None, error=self.fatal or f"clamonacc s'est arrêté : {reason}")
        return 1

    def _read_stdout(self):
        for line in self.process.stdout:
            say(line.rstrip())
            if "FOUND" not in line:          # les menaces sont lues dans le journal (sans doublon)
                self.handle_line(line)

    def clamd_alive(self):
        """PING au socket de clamd (même socket que clamonacc)."""
        try:
            with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
                sock.settimeout(10)
                sock.connect(shield.clamd_socket(shield.CLAMONACC_CONF))
                sock.sendall(b"zPING\0")
                return sock.recv(16).startswith(b"PONG")
        except OSError:
            return False

    def _health(self):
        """clamd doit répondre ; sinon « erreur » (jamais « protégé ») jusqu'à une nouvelle vérification."""
        last_verify = time.monotonic()
        down = False
        while not self.stopping and self.process.poll() is None:
            time.sleep(HEALTH_SECONDS)
            if self.stopping or not self.ready.is_set() or self.verifying:
                continue
            if not self.clamd_alive():
                if not down:
                    say("clamd ne répond plus : protection en temps réel inopérante.")
                    self.status("error", verified=None, error="Le service d'analyse (clamd) ne répond plus : les "
                                "fichiers ne sont pas analysés.")
                down = True
                continue
            if down or time.monotonic() - last_verify > REVERIFY_SECONDS:
                down = False
                last_verify = time.monotonic()
                self.verify()

    def _verify_when_ready(self):
        # clamonacc annonce sa boucle fanotify ; sans cette ligne (versions différentes), on essaie quand même.
        self.ready.wait(120)
        time.sleep(2)
        if not self.stopping and self.process.poll() is None:
            self.verify()

    def cleanup(self):
        if self.selftest_dir is not None:
            try:
                parent = os.open(self.selftest_dir.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
            except OSError:
                return
            try:
                self._remove_selftest(parent)
            except OSError:
                pass
            finally:
                os.close(parent)

    def stop(self, *_args):
        self.stopping = True
        if self.process is not None and self.process.poll() is None:
            self.process.terminate()
            try:
                self.process.wait(10)
            except subprocess.TimeoutExpired:
                self.process.kill()


def main():
    monitor = Monitor()
    signal.signal(signal.SIGTERM, monitor.stop)
    signal.signal(signal.SIGINT, monitor.stop)
    signal.signal(signal.SIGUSR1, lambda *_a: threading.Thread(target=monitor.verify, daemon=True).start())
    return monitor.run()


if __name__ == "__main__":
    sys.exit(main())
