Set-OPS-Public/scripts/appliquer_proxmox_fw.py

#!/usr/bin/env python3
"""Reconcilie le pare-feu Proxmox (est-ouest intra-tenant) avec son devis.

Trois couches, toutes au niveau du CLUSTER sauf la derniere :
  - IPSets          : qui porte quel role
  - Groupes         : les flux entrants d'un role
  - Affectations    : quels groupes sur quelle VM

DEUX SENS : ce que le devis demande et qui manque est cree, ce qu'il ne demande
plus est RETIRE. Un groupe orphelin ne bloque rien, mais il decrit une politique
qui n'est plus la notre.

LE DROP EST PORTE PAR LA VM, jamais par le datacenter. Au datacenter, `policy_in`
est la politique par defaut de TOUTE VM dont le pare-feu s'active — un parc herite
sans regles tomberait d'un bloc. Pose sur chaque VM tenant, il donne la meme
isolation sans cette falaise, et le script le fait lui-meme.

Il n'active pas le pare-feu du datacenter (`enable=1`) : c'est un reglage de
cluster, decide une fois, et signale tant qu'il manque.

PERIMETRE STRICT : seuls les objets prefixes par l'etiquette d'un tenant du devis
(`t11-`, `t17-`) sont touches. Le reste du cluster n'existe pas pour ce script.

NON DESTRUCTIF PAR DEFAUT : sans `CONFIRMER=true`, aucune ecriture (regle 4).

Usage :
  python3 scripts/appliquer_proxmox_fw.py                  # plan seul
  CONFIRMER=true python3 scripts/appliquer_proxmox_fw.py   # applique
"""
from __future__ import annotations

import json
import os
import subprocess
import sys
from pathlib import Path

RACINE = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(RACINE / "scripts"))

from proxmox_api import Cluster  # noqa: E402


def _prefixe(bloc: dict) -> str:
    """`t11-` — deduit du premier IPSet, qui les porte tous. Jamais saisi."""
    for nom in bloc.get("ipsets") or {}:
        return nom.split("-")[0] + "-"
    for g in bloc.get("groupes") or []:
        return str(g["nom"]).split("-")[0] + "-"
    return ""


def _norm(cidr: str) -> str:
    """Forme comparable d'un membre d'IPSet.

    Proxmox RANGE `192.168.255.2/32` sous la forme `192.168.255.2`. Comparer les deux
    litteralement laisse un ecart qui ne se referme jamais : chaque passage croit devoir
    corriger, et la reconciliation ne converge plus.
    """
    c = str(cidr).strip()
    for suffixe in ("/32", "/128"):
        if c.endswith(suffixe):
            return c[: -len(suffixe)]
    return c


def _regle_cle(r: dict) -> tuple:
    """Identite d'une regle de groupe, insensible a la position et au commentaire."""
    return (str(r.get("type") or r.get("sens") or "").lower(),
            str(r.get("action") or "").upper(),
            str(r.get("source") or ""),
            str(r.get("proto") or ""),
            str(r.get("dport") or ""))


def plan(api: Cluster, devis: dict) -> dict:
    prefixes = tuple(_prefixe(b) for b in devis["blocs"] if _prefixe(b))

    ipsets_voulus, groupes_voulus, affect_voulues = {}, {}, {}
    for b in devis["blocs"]:
        for nom, d in (b.get("ipsets") or {}).items():
            ipsets_voulus[nom] = {"membres": sorted({_norm(m) for m in d["membres"]}),
                                  "role": d.get("role", "")}
        for g in b.get("groupes") or []:
            groupes_voulus[g["nom"]] = g
        for a in b.get("affectations") or []:
            affect_voulues[int(a["vmid"])] = {"hote": a["hote"], "groupes": sorted(a["groupes"])}

    # --- etat du cluster, restreint a nos prefixes -----------------------------
    ipsets_poses = {}
    for s in (api("/cluster/firewall/ipset") or []):
        if isinstance(s, dict) and str(s.get("name", "")).startswith(prefixes):
            membres = [str(m.get("cidr")) for m in (api(f"/cluster/firewall/ipset/{s['name']}") or [])
                       if isinstance(m, dict)]
            ipsets_poses[s["name"]] = sorted({_norm(m) for m in membres})

    groupes_poses = {}
    for g in (api("/cluster/firewall/groups") or []):
        if isinstance(g, dict) and str(g.get("group", "")).startswith(prefixes):
            regles = [r for r in (api(f"/cluster/firewall/groups/{g['group']}") or [])
                      if isinstance(r, dict)]
            groupes_poses[g["group"]] = regles

    vm_du_cluster = {int(r["vmid"]): r["node"] for r in (api("/cluster/resources?type=vm") or [])
                     if isinstance(r, dict) and r.get("vmid")}

    affect_posees, vm_absentes = {}, []
    for vmid in affect_voulues:
        noeud = vm_du_cluster.get(vmid)
        if not noeud:
            vm_absentes.append(vmid)
            continue
        regles = api(f"/nodes/{noeud}/qemu/{vmid}/firewall/rules") or []
        o = api(f"/nodes/{noeud}/qemu/{vmid}/firewall/options") or {}
        affect_posees[vmid] = {
            "noeud": noeud,
            "groupes": sorted(str(r.get("action")) for r in regles
                              if isinstance(r, dict) and r.get("type") == "group"),
            "actif": str(o.get("enable", "")),
            # Le DROP vit ICI, sur la VM du tenant — pas au datacenter, ou il vaudrait
            # pour tout le parc, y compris ce qui n'appartient a aucun tenant.
            "politique": str(o.get("policy_in", "")).upper(),
        }

    opts = api("/cluster/firewall/options") or {}
    return {
        "ipsets_creer": {n: v for n, v in ipsets_voulus.items() if n not in ipsets_poses},
        "ipsets_majer": {n: (ipsets_poses[n], v["membres"]) for n, v in ipsets_voulus.items()
                         if n in ipsets_poses and ipsets_poses[n] != v["membres"]},
        "ipsets_retirer": sorted(n for n in ipsets_poses if n not in ipsets_voulus),
        "groupes_creer": {n: g for n, g in groupes_voulus.items() if n not in groupes_poses},
        "groupes_majer": {n: g for n, g in groupes_voulus.items()
                          if n in groupes_poses
                          and {_regle_cle(r) for r in g["regles"]}
                          != {_regle_cle(r) for r in groupes_poses[n]}},
        "groupes_retirer": sorted(n for n in groupes_poses if n not in groupes_voulus),
        "affect_majer": {v: a for v, a in affect_voulues.items()
                         if v in affect_posees
                         and (affect_posees[v]["groupes"] != a["groupes"]
                              or affect_posees[v]["actif"] != "1"
                              or affect_posees[v]["politique"] != "DROP")},
        "affect_posees": affect_posees,
        "vm_absentes": sorted(vm_absentes),
        "datacenter": {"actif": str(opts.get("enable", "")), "politique": str(opts.get("policy_in", ""))},
        "_voulus": {"ipsets": ipsets_voulus, "groupes": groupes_voulus, "affect": affect_voulues},
    }


def afficher(p: dict) -> bool:
    for n in sorted(p["ipsets_creer"]):
        print(f"  + IPSet                 {n:<22} {len(p['ipsets_creer'][n]['membres'])} membre(s)")
    for n, (avant, apres) in sorted(p["ipsets_majer"].items()):
        print(f"  ~ IPSet                 {n:<22} {len(avant)} -> {len(apres)} membre(s)")
    for n in p["ipsets_retirer"]:
        print(f"  - IPSet PERIME          {n}")
    for n, g in sorted(p["groupes_creer"].items()):
        print(f"  + groupe                {n:<22} {len(g['regles'])} regle(s)   # {g.get('role','')}")
    for n in sorted(p["groupes_majer"]):
        print(f"  ~ groupe                {n:<22} regles differentes")
    for n in p["groupes_retirer"]:
        print(f"  - groupe PERIME         {n}")
    for v, a in sorted(p["affect_majer"].items()):
        print(f"  ~ VM {v:<12} {a['hote']:<16} -> {', '.join(a['groupes'])}")
    if p["vm_absentes"]:
        print(f"\n  {len(p['vm_absentes'])} VM du devis absente(s) du cluster — affectation "
              f"differee, elle se posera au clonage :")
        print(f"    {', '.join(str(v) for v in p['vm_absentes'][:8])}"
              + (" …" if len(p["vm_absentes"]) > 8 else ""))
    dc = p["datacenter"]
    if dc["actif"] != "1":
        print(f"\n  /!\\ PREREQUIS NON REMPLI — pare-feu du datacenter desactive "
              f"(enable={dc['actif'] or '0'}).")
        print("      Sans lui, RIEN ne filtre : les objets ci-dessus restent inertes.")
        print("      `enable=1` seul ne ferme rien — une VM n'est filtree que si SON propre")
        print("      `enable` vaut 1 (defaut 0) et que sa carte porte `firewall=1`.")
        print("      Ce script ne le bascule pas : c'est un reglage de cluster, decide une fois.")
    if dc["politique"].upper() in ("DROP", "REJECT"):
        print(f"\n  /!\\ DANGER — `policy_in={dc['politique']}` AU DATACENTER.")
        print("      C'est la politique par defaut de TOUTE VM dont le pare-feu s'active,")
        print("      y compris ce qui n'appartient a aucun tenant. Set-OPS pose le DROP")
        print("      PAR VM tenant : cette valeur au datacenter n'est pas requise, et expose")
        print("      le reste du parc. La remettre a ACCEPT.")
    creer = len(p["ipsets_creer"]) + len(p["groupes_creer"])
    majer = len(p["ipsets_majer"]) + len(p["groupes_majer"]) + len(p["affect_majer"])
    retirer = len(p["ipsets_retirer"]) + len(p["groupes_retirer"])
    print(f"\n  a creer : {creer}   |  a mettre a jour : {majer}   |  a retirer : {retirer}")
    return bool(creer or majer or retirer)


def appliquer(api: Cluster, p: dict) -> int:
    echecs = 0

    def _fait(rep, quoi):
        nonlocal echecs
        if (e := api.rate(rep)):
            echecs += 1
            print(f"  ! ECHEC {quoi} : {e[:150]}")
            return False
        return True

    # 1. IPSets AVANT les groupes : une regle qui reference un IPSet absent est refusee.
    for n, v in sorted(p["ipsets_creer"].items()):
        if _fait(api("/cluster/firewall/ipset", "POST",
                     {"name": n, "comment": v["role"][:100]}), f"ipset {n}"):
            for m in v["membres"]:
                _fait(api(f"/cluster/firewall/ipset/{n}", "POST", {"cidr": m}), f"{n} += {m}")
    for n, (avant, apres) in sorted(p["ipsets_majer"].items()):
        for m in sorted(set(apres) - set(avant)):
            _fait(api(f"/cluster/firewall/ipset/{n}", "POST", {"cidr": m}), f"{n} += {m}")
        for m in sorted(set(avant) - set(apres)):
            _fait(api(f"/cluster/firewall/ipset/{n}/{m}", "DELETE"), f"{n} -= {m}")

    # 2. Groupes. Une mise a jour REMPLACE les regles : elles sont a nous, et les
    #    comparer une a une pour un edit partiel couterait plus que de les reposer.
    for n in sorted(p["groupes_majer"]):
        for r in reversed(api(f"/cluster/firewall/groups/{n}") or []):
            _fait(api(f"/cluster/firewall/groups/{n}/{r['pos']}", "DELETE"), f"purge {n}")
    for n, g in sorted({**p["groupes_creer"], **p["groupes_majer"]}.items()):
        if n in p["groupes_creer"]:
            _fait(api("/cluster/firewall/groups", "POST",
                      {"group": n, "comment": str(g.get("role", ""))[:100]}), f"groupe {n}")
        for r in g["regles"]:
            corps = {"type": str(r.get("sens", "in")).lower(), "action": r["action"],
                     "enable": 1, "comment": str(r.get("via") or g.get("role", ""))[:100]}
            for cle, champ in (("source", "source"), ("proto", "proto"), ("dport", "dport")):
                if r.get(cle):
                    corps[champ] = r[cle]
            _fait(api(f"/cluster/firewall/groups/{n}", "POST", corps), f"regle de {n}")

    # 3. Affectations aux VM, et activation de leur pare-feu — sans quoi les groupes
    #    seraient poses sur une machine qui ne filtre pas.
    for v, a in sorted(p["affect_majer"].items()):
        noeud = p["affect_posees"][v]["noeud"]
        for r in reversed(api(f"/nodes/{noeud}/qemu/{v}/firewall/rules") or []):
            if isinstance(r, dict) and r.get("type") == "group":
                _fait(api(f"/nodes/{noeud}/qemu/{v}/firewall/rules/{r['pos']}", "DELETE"),
                      f"purge VM {v}")
        for g in a["groupes"]:
            _fait(api(f"/nodes/{noeud}/qemu/{v}/firewall/rules", "POST",
                      {"type": "group", "action": g, "enable": 1}), f"VM {v} += {g}")
        # `policy_in=DROP` sur LA VM : c'est ce qui rend les groupes ci-dessus exclusifs.
        # Au datacenter, la meme valeur s'appliquerait a tout ce qui n'est pas un tenant.
        _fait(api(f"/nodes/{noeud}/qemu/{v}/firewall/options", "PUT",
                  {"enable": 1, "policy_in": "DROP"}), f"pare-feu de la VM {v}")

    # 4. Retraits : groupes avant IPSets, un IPSet reference ne se supprime pas.
    for n in p["groupes_retirer"]:
        for r in reversed(api(f"/cluster/firewall/groups/{n}") or []):
            _fait(api(f"/cluster/firewall/groups/{n}/{r['pos']}", "DELETE"), f"purge {n}")
        _fait(api(f"/cluster/firewall/groups/{n}", "DELETE"), f"retrait groupe {n}")
    for n in p["ipsets_retirer"]:
        _fait(api(f"/cluster/firewall/ipset/{n}", "DELETE", {"force": 1}), f"retrait ipset {n}")

    if echecs:
        print(f"\n  {echecs} echec(s) — la reconciliation est INCOMPLETE.")
        return 1
    print("\n  Pare-feu est-ouest reconcilie.")
    return 0


def main() -> int:
    api, base = Cluster.depuis_hebergeur()
    # `base` est l'HEBERGEUR : SETOPS_INVENTAIRE (exporte par le Makefile) gagnerait sur
    # SETOPS_INSTANCE et ferait lire l'inventaire du tenant actif. Cf. prouver.py P03.
    env_heb = {**os.environ, "SETOPS_INSTANCE": str(base)}
    env_heb.pop("SETOPS_INVENTAIRE", None)
    r = subprocess.run([sys.executable, str(RACINE / "scripts" / "devis_proxmox_fw.py"), "--json"],
                       cwd=RACINE, capture_output=True, text=True, env=env_heb)
    if r.returncode != 0:
        raise SystemExit("Le devis ne se genere pas :\n" + r.stderr.strip()[:400])
    devis = json.loads(r.stdout)

    print(f"Cluster {api.hote} — {len(devis['blocs'])} tenant(s) au devis\n")
    p = plan(api, devis)
    quelque_chose = afficher(p)
    if not quelque_chose:
        print("\n  Le cluster dit deja ce que le devis dit. Rien a faire.")
        return 0
    if os.environ.get("CONFIRMER") != "true":
        print("\n  PLAN SEUL — aucune ecriture. Rejouer avec CONFIRMER=true pour appliquer.")
        return 0
    print()
    return appliquer(api, p)


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