Set-OPS-Public/scripts/verifier_signature.py

#!/usr/bin/env python3
"""Verifie une signature PGP detachee contre une empreinte EPINGLEE.

Pourquoi ce script existe. Keycloak signe ses archives, et c'est plus fort qu'une somme de
controle : une somme prouve que le fichier n'a pas ete corrompu, une signature prouve QUI
l'a produit. Encore faut-il savoir a quelle cle se fier — sinon on verifie qu'une archive
est bien signee par celui qui l'a signee, ce qui ne prouve rien.

D'ou les trois exigences que ce script impose :

  1. **La cle publique vit DANS LE DEPOT**, versionnee et relue. Aucune interrogation de
     serveur de cles au moment du deploiement : un serveur de cles n'est pas une autorite,
     et dependre de lui rendrait la verification aussi fragile que ce qu'elle protege.
  2. **L'empreinte attendue est EPINGLEE** a cote de la version. Une cle qui change en
     amont devient alors un echec BRUYANT, qui exige une relecture humaine — au lieu d'un
     remplacement silencieux.
  3. **Un trousseau JETABLE**. `GNUPGHOME` pointe sur un dossier temporaire : le trousseau
     personnel de l'exploitant n'est jamais lu ni modifie, et le resultat ne depend pas de
     ce qu'il contient. Deux executions sur deux machines donnent la meme reponse.

CE QUE CA NE PROUVE PAS, et il faut le dire : que l'empreinte epinglee soit la bonne. Ca,
aucune machine ne peut l'etablir — c'est une decision humaine, prise par un canal
independant, puis ECRITE ici. Le script garantit seulement qu'on ne s'en ecarte pas.

  python3 scripts/verifier_signature.py --artefact X --signature X.asc \\
      --cle roles/<role>/files/<cle>.asc --empreinte <40 hex>
"""
from __future__ import annotations

import argparse
import re
import shutil
import subprocess
import sys
import tempfile
from pathlib import Path


def _gpg(maison: Path, *args: str) -> subprocess.CompletedProcess:
    return subprocess.run(["gpg", "--homedir", str(maison), "--batch", "--no-tty",
                           "--status-fd", "1", *args],
                          capture_output=True, text=True)


def verifier(artefact: Path, signature: Path, cle: Path, empreinte: str) -> tuple[bool, str]:
    empreinte = re.sub(r"\s+", "", empreinte).upper()
    if not re.fullmatch(r"[0-9A-F]{40}", empreinte):
        return False, f"empreinte epinglee invalide : « {empreinte} » (40 hexa attendus)"
    for f in (artefact, signature, cle):
        if not f.is_file():
            return False, f"fichier absent : {f}"
    if shutil.which("gpg") is None:
        return False, "gpg est absent du controleur — impossible de verifier quoi que ce soit"

    with tempfile.TemporaryDirectory(prefix="setops-gpg-") as tmp:
        maison = Path(tmp)
        maison.chmod(0o700)

        imp = _gpg(maison, "--import", str(cle))
        if imp.returncode != 0:
            return False, f"cle publique illisible : {imp.stderr.strip()[:160]}"

        # La cle du depot doit ETRE celle qu'on a epinglee. Sans ce controle, remplacer le
        # fichier de cle suffirait a faire passer n'importe quelle signature.
        montre = _gpg(maison, "--with-colons", "--fingerprint", "--list-keys")
        empreintes = [l.split(":")[9] for l in montre.stdout.splitlines()
                      if l.startswith("fpr:")]
        if empreinte not in empreintes:
            return False, (f"la cle du depot ne porte pas l'empreinte epinglee.\n"
                           f"     epinglee : {empreinte}\n"
                           f"     trouvee  : {', '.join(empreintes) or '(aucune)'}")

        v = _gpg(maison, "--verify", str(signature), str(artefact))
        etat = v.stdout + v.stderr
        if "GOODSIG" not in etat and "[GNUPG:] VALIDSIG" not in etat:
            motif = re.search(r"\[GNUPG:\] (BADSIG|ERRSIG|NO_PUBKEY|EXPKEYSIG|REVKEYSIG)\S*.*",
                              etat)
            return False, ("signature INVALIDE : "
                           + (motif.group(0) if motif else etat.strip()[:200]))
        # La signature est bonne — mais par QUELLE cle ? `VALIDSIG` porte l'empreinte
        # reelle du signataire ; s'en remettre a « bonne signature » sans la lire
        # laisserait passer une signature valide faite par une autre cle du trousseau.
        vs = re.search(r"\[GNUPG:\] VALIDSIG ([0-9A-F]{40})", etat)
        if not vs:
            return False, "signature acceptee mais sans empreinte lisible — refuse"
        if vs.group(1) != empreinte:
            return False, (f"signee par une AUTRE cle que celle epinglee.\n"
                           f"     epinglee : {empreinte}\n"
                           f"     signataire : {vs.group(1)}")
        return True, f"signature valide, faite par {empreinte}"


def main(argv: list[str] | None = None) -> int:
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--artefact", required=True, type=Path)
    ap.add_argument("--signature", required=True, type=Path)
    ap.add_argument("--cle", required=True, type=Path)
    ap.add_argument("--empreinte", required=True)
    a = ap.parse_args(argv)
    ok, message = verifier(a.artefact, a.signature, a.cle, a.empreinte)
    print(("  OK    " if ok else "  REFUS ") + message)
    if not ok:
        print("\n  L'artefact n'est PAS installe. Si le changement est legitime (rotation de\n"
              "  cle en amont), il faut RELIRE la nouvelle empreinte par un canal\n"
              "  independant, puis mettre a jour la cle du depot et l'epinglage.")
    return 0 if ok else 1


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