commit f8f958756e6e9376260ccabc8fb393dafde429ac Author: Theo Gastinel Date: Sun Nov 1 02:58:52 2026 +0100 Outils Pumpkin : sauvegarde, sante, note online_mode Co-Authored-By: Claude Sonnet 5.5 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..1bbd695 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +*.sh text eol=lf +*.py text eol=lf diff --git a/NOTE-online-mode-false.md b/NOTE-online-mode-false.md new file mode 100644 index 0000000..6d6a848 --- /dev/null +++ b/NOTE-online-mode-false.md @@ -0,0 +1,27 @@ +# Risques de online_mode=false sur le serveur Pumpkin + +Constat lu sur le serveur (lecture seule, 01/11/2026) : `online_mode = false`, `white_list = false`, +`enforce_whitelist = false`, `max_players = 30`, `op_permission_level = 4`, `default_op_level = 0`, +plugins : dossier vide, `allow_unsigned = true`, `verify_signatures = true`. +`packet_limiter` actif (500 paquets/s), `anti_spam` du chat actif. + +## Risques +| Risque | Gravité | Détail | +|---|---|---| +| Usurpation de pseudo | Haute | Sans vérification Mojang, n'importe qui se connecte avec le pseudo d'un autre. L'UUID est dérivé du pseudo : il hérite de l'inventaire, de la position et des droits du vrai joueur. | +| Prise de contrôle d'un op | Haute si des ops existent | Usurper un op = être op. Mitigation actuelle : n'avoir aucun op (`ops.json` vide). À ne jamais changer sans auth. | +| Bans contournables | Moyenne | Un ban par pseudo/UUID se contourne en changeant de pseudo ; sans whitelist, tout le monde peut revenir. | +| Saturation / bots | Moyenne | 30 places prises par des faux comptes. | +| Skins/cape | Faible | `textures` limité à `.minecraft.net` et `.mojang.com`, bon réglage. | +| IP réelles | Info | Le VPS conserve la vraie IP (wg1) : utile pour bans par IP et rate-limit. | + +## Mitigations sans whitelist (par ordre de rapport efficacité/effort) +1. **Aucun op** et aucune commande sensible pour un joueur normal (état actuel : `default_op_level = 0`). Ne pas donner op à un pseudo. +2. **Rate-limit sur le VPS** : déjà en place (nftables sur le VPS, à citer d'après la fiche, non revérifié ici). Vérifier qu'il couvre bien 25565/tcp et pas seulement le vocal. +3. **Plugin d'authentification Pumpkin** : une recherche web trouve un plugin tiers, **0glnAuth** (WASM, port Rust de la logique AuthMe/JPremium, `/register` + `/login`, exige `online_mode=false`). Non officiel, **non testé**, mainteneur et audit inconnus ; le README prévient que si le plugin ne charge pas, le serveur tourne **sans auth** (échec ouvert). À lire (code, permissions fichier/HTTP demandées) avant tout essai ; essai seulement sur une copie, jamais sur le serveur en production sans l'accord de Théo. Je n'ai pas pu confirmer qu'un plugin d'auth officiel Pumpkin existe. +4. **Bascule en `online_mode = true`** : supprime l'usurpation, mais change les UUID des joueurs existants (migration obligatoire, comme pour NeoForge). Les joueurs sans compte Java payant ne pourraient plus entrer. C'est une décision de Théo. +5. **Whitelist** : écartée par Théo (serveur ouvert). Alternative légère : liste d'accès côté VPS (IP) pour une période de test. +6. **Surveillance** : `sante-pumpkin.py` remonte joueurs connectés et pseudos (échantillon) ; une alerte sur un nombre de joueurs anormal est facile à ajouter au Centre de suivi. +7. **Sauvegarde quotidienne** (`sauvegarde-pumpkin.sh`) : limite les dégâts d'un grief d'un joueur usurpé. + +Sources web : [0glnAuth v0.1.0](https://github.com/TuiLaZeroTwo/0glnAuth/releases/tag/v0.1.0), [Securing an Offline Server](https://docs.fps.ms/minecraft/securing-an-offline-server). diff --git a/README.md b/README.md new file mode 100644 index 0000000..7f75908 --- /dev/null +++ b/README.md @@ -0,0 +1,10 @@ +# minecraft-pumpkin-outils + +Outils pour le serveur Minecraft Pumpkin (cornafserver, `~/minecraft-pumpkin`). Rien ici ne redémarre ni ne modifie le serveur. + +- `sauvegarde-pumpkin.sh` : archive à chaud datée (`.tar.zst`), rétention 7/4/3, `--simulation`. Même disposition que `sauvegarde-minecraft.sh` : `copie-croc.sh` l'accepte si `SRC` pointe sur le dossier de destination (non branché, à décider par Théo). +- `sante-pumpkin.py` : ping status + `docker stats` + âge de sauvegarde, une ligne JSON, code de sortie 0/1/2. +- `NOTE-online-mode-false.md` : risques et mitigations. + +Testé réellement : santé sur le serveur réel (lecture seule), sauvegarde sur une copie du monde dans `/tmp` (supprimée ensuite). +Non testé : planification cron, envoi vers crocserver, intégration au Centre de suivi. diff --git a/sante-pumpkin.py b/sante-pumpkin.py new file mode 100644 index 0000000..7f89a92 --- /dev/null +++ b/sante-pumpkin.py @@ -0,0 +1,133 @@ +#!/usr/bin/env python3 +"""Sante du serveur Minecraft Pumpkin, pour le Centre de suivi. + +Lecture seule : ping "Server List Ping" (status), docker stats --no-stream, age de la derniere sauvegarde. +Sortie : une ligne JSON sur stdout. Code de sortie : 0 ok, 1 degrade (avertissement), 2 hors service. + +Usage : sante-pumpkin.py [--hote 127.0.0.1] [--port 25565] [--conteneur minecraft-pumpkin] + [--sauvegardes /mnt/hdd2/sauvegardes-minecraft-pumpkin] [--ram-max-pct 85] +""" +import argparse, json, socket, struct, subprocess, sys, time + + +def varint(n): + out = b"" + while True: + b = n & 0x7F + n >>= 7 + out += bytes([b | (0x80 if n else 0)]) + if not n: + return out + + +def lire_varint(s): + r = 0 + for i in range(5): + b = s.recv(1) + if not b: + raise IOError("connexion fermee") + r |= (b[0] & 0x7F) << (7 * i) + if not b[0] & 0x80: + return r + raise IOError("varint trop long") + + +def lire_n(s, n): + buf = b"" + while len(buf) < n: + c = s.recv(n - len(buf)) + if not c: + raise IOError("reponse tronquee") + buf += c + return buf + + +def ping(hote, port, delai=5): + t0 = time.time() + with socket.create_connection((hote, port), timeout=delai) as s: + h = hote.encode() + data = b"\x00" + varint(767) + varint(len(h)) + h + struct.pack(">H", port) + varint(1) + s.sendall(varint(len(data)) + data) + s.sendall(b"\x01\x00") + taille = lire_varint(s) + corps = lire_n(s, taille) + pid = corps[0] + if pid != 0: + raise IOError("paquet inattendu %d" % pid) + i = 1 + l = 0 + for k in range(5): + b = corps[i]; i += 1 + l |= (b & 0x7F) << (7 * k) + if not b & 0x80: + break + rep = json.loads(corps[i:i + l].decode("utf-8")) + return rep, round((time.time() - t0) * 1000) + + +def pct(x): + return float(x.strip().rstrip("%").replace(",", ".")) + + +def docker_stats(nom): + out = subprocess.run( + ["docker", "stats", "--no-stream", "--format", "{{.CPUPerc}}|{{.MemUsage}}|{{.MemPerc}}", nom], + capture_output=True, text=True, timeout=30).stdout.strip() + if not out: + return None + cpu, mem, mp = out.split("|") + return {"cpu_pct": pct(cpu), "ram": mem.strip(), "ram_pct": pct(mp)} + + +def age_sauvegarde_h(dossier): + import glob, os + fs = glob.glob(dossier + "/quotidien/*.tar.zst") + if not fs: + return None + return round((time.time() - max(os.path.getmtime(f) for f in fs)) / 3600, 1) + + +def main(): + a = argparse.ArgumentParser() + a.add_argument("--hote", default="127.0.0.1") + a.add_argument("--port", type=int, default=25565) + a.add_argument("--conteneur", default="minecraft-pumpkin") + a.add_argument("--sauvegardes", default="") + a.add_argument("--ram-max-pct", type=float, default=85) + a.add_argument("--age-max-h", type=float, default=30) + a = a.parse_args() + + r = {"service": "minecraft-pumpkin", "ts": int(time.time()), "etat": "ok", "alertes": []} + try: + rep, ms = ping(a.hote, a.port) + j = rep.get("players", {}) + r.update(ping_ms=ms, version=rep.get("version", {}).get("name"), + joueurs=j.get("online"), max_joueurs=j.get("max"), + pseudos=[p.get("name") for p in j.get("sample", [])]) + except Exception as e: + r["etat"] = "hors_service" + r["alertes"].append("ping status en echec : %s" % e) + try: + st = docker_stats(a.conteneur) + if st is None: + r["etat"] = "hors_service" + r["alertes"].append("conteneur %s absent ou arrete" % a.conteneur) + else: + r.update(st) + if st["ram_pct"] > a.ram_max_pct: + r["alertes"].append("RAM %.0f %% > %.0f %%" % (st["ram_pct"], a.ram_max_pct)) + except Exception as e: + r["alertes"].append("docker stats indisponible : %s" % e) + if a.sauvegardes: + age = age_sauvegarde_h(a.sauvegardes) + r["sauvegarde_age_h"] = age + if age is None or age > a.age_max_h: + r["alertes"].append("derniere sauvegarde absente ou > %d h" % a.age_max_h) + if r["alertes"] and r["etat"] == "ok": + r["etat"] = "degrade" + print(json.dumps(r, ensure_ascii=False)) + sys.exit({"ok": 0, "degrade": 1}.get(r["etat"], 2)) + + +if __name__ == "__main__": + main() diff --git a/sauvegarde-pumpkin.sh b/sauvegarde-pumpkin.sh new file mode 100644 index 0000000..eb3563d --- /dev/null +++ b/sauvegarde-pumpkin.sh @@ -0,0 +1,60 @@ +#!/bin/bash +# Sauvegarde a chaud du monde Pumpkin (archive datee + retention). +# Meme disposition que sauvegarde-minecraft.sh (NeoForge) : /{quotidien,hebdo,mensuel}/-AAAAMMJJ-HHMM.tar.zst +# -> compatible avec copie-croc.sh (il parcourt $SRC/{mensuel,hebdo,quotidien}/*.tar.zst) si SRC pointe sur . +# +# Usage : sauvegarde-pumpkin.sh [--simulation] +# Variables (toutes facultatives) : +# PUMPKIN_DATA donnees du serveur (defaut /mnt/nvme/minecraft/pumpkin) +# DEST dossier des archives (defaut /mnt/hdd2/sauvegardes-minecraft-pumpkin) +# MONDE dossier du monde (defaut world) +# GARDER_Q/H/M retention (defaut 7 / 4 / 3) +# SAVE_CMD commande facultative lancee AVANT l'archive pour forcer une ecriture disque +# (ex. un envoi "save-all" a la console). Vide par defaut : Pumpkin n'a pas de RCON +# par defaut ici et on ne touche pas a la console du conteneur. +# Sauvegarde a chaud = coherente "a un crash pres" : Pumpkin ecrit seul (autosave_ticks) ; en cas +# de doute, restaurer l'archive de la veille. Le script ne redemarre ni ne modifie rien. +set -euo pipefail + +SIMU=0; [ "${1:-}" = "--simulation" ] && SIMU=1 +PUMPKIN_DATA="${PUMPKIN_DATA:-/mnt/nvme/minecraft/pumpkin}" +DEST="${DEST:-/mnt/hdd2/sauvegardes-minecraft-pumpkin}" +MONDE="${MONDE:-world}" +GARDER_Q="${GARDER_Q:-7}"; GARDER_H="${GARDER_H:-4}"; GARDER_M="${GARDER_M:-3}" +DATE=$(date +%Y%m%d-%H%M) +JOURNAL="$DEST/journal.log" +log() { echo "$(date '+%F %T') $*" | tee -a "$JOURNAL" >&2; } + +[ -d "$PUMPKIN_DATA/$MONDE" ] || { echo "Monde introuvable : $PUMPKIN_DATA/$MONDE" >&2; exit 2; } +command -v zstd >/dev/null || { echo "zstd absent" >&2; exit 2; } + +# garde-fou : au moins 2x la taille du monde de libre +besoin=$(du -sk "$PUMPKIN_DATA/$MONDE" | cut -f1) +mkdir -p "$DEST"/{quotidien,hebdo,mensuel} +libre=$(df -Pk "$DEST" | awk 'NR==2{print $4}') +[ "$libre" -gt $((besoin * 2 + 102400)) ] || { log "ECHEC place insuffisante (${libre} Ko libres, monde ${besoin} Ko)"; exit 3; } + +if [ "$SIMU" = 1 ]; then + echo "[simulation] archive : $DEST/quotidien/pumpkin-$MONDE-$DATE.tar.zst (monde ${besoin} Ko, ${libre} Ko libres)" + echo "[simulation] retention : $GARDER_Q quotidiennes, $GARDER_H hebdo, $GARDER_M mensuelles" + exit 0 +fi + +[ -z "${SAVE_CMD:-}" ] || { log "SAVE_CMD"; bash -c "$SAVE_CMD" || log "avertissement : SAVE_CMD en echec"; sleep 5; } + +ARCHIVE="$DEST/quotidien/pumpkin-$MONDE-$DATE.tar.zst" +# 1 = fichiers modifies pendant la lecture : acceptable pour une sauvegarde a chaud +rc=0 +tar -C "$PUMPKIN_DATA" --zstd -cf "$ARCHIVE.part" \ + "$MONDE" pumpkin.toml data plugins 2>/dev/null || rc=$? +[ "$rc" -le 1 ] || { rm -f "$ARCHIVE.part"; log "ECHEC tar (code $rc)"; exit 1; } +zstd -tq "$ARCHIVE.part" || { rm -f "$ARCHIVE.part"; log "ECHEC archive corrompue (test zstd)"; exit 1; } +mv "$ARCHIVE.part" "$ARCHIVE" + +[ "$(date +%u)" = 7 ] && cp "$ARCHIVE" "$DEST/hebdo/" +[ "$(date +%d)" = 01 ] && cp "$ARCHIVE" "$DEST/mensuel/" + +garder() { ls -1t "$DEST/$1"/*.tar.zst 2>/dev/null | tail -n +$(($2 + 1)) | xargs -r rm -f || true; } +garder quotidien "$GARDER_Q"; garder hebdo "$GARDER_H"; garder mensuel "$GARDER_M" + +log "OK $(basename "$ARCHIVE") $(du -h "$ARCHIVE" | cut -f1) (tar code $rc)"