Outils Pumpkin : sauvegarde, sante, note online_mode

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Theo GastineletClaude Sonnet 5.5 a révisé 2026-11-01 02:58:52 +01:00
révision f8f958756e
5 fichiers modifiés
+232

Aucun fichier ne correspond à votre recherche

+2
Voir le fichier
@@ -0,0 +1,2 @@
*.sh text eol=lf
*.py text eol=lf
+27
Voir le fichier
@@ -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).
+10
Voir le fichier
@@ -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.
+133
Voir le fichier
@@ -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()
+60
Voir le fichier
@@ -0,0 +1,60 @@
#!/bin/bash
# Sauvegarde a chaud du monde Pumpkin (archive datee + retention).
# Meme disposition que sauvegarde-minecraft.sh (NeoForge) : <DEST>/{quotidien,hebdo,mensuel}/<nom>-AAAAMMJJ-HHMM.tar.zst
# -> compatible avec copie-croc.sh (il parcourt $SRC/{mensuel,hebdo,quotidien}/*.tar.zst) si SRC pointe sur <DEST>.
#
# 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)"