From c45ec6df7b323f88f7ac06f9bdc57c63dd92414d Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Wed, 14 Oct 2026 08:30:34 +0200 Subject: [PATCH] Audit 2026-10-14 : synthese, inventaire, failles F01-F25, tests de preuve Co-Authored-By: Claude Opus 5.5 --- audit/00-SYNTHESE.md | 69 +++++ audit/01-inventaire-triches.md | 135 +++++++++ audit/02-failles-detection.md | 234 +++++++++++++++ audit/AVANCEMENT.md | 16 + audit/tests-proposes/AuditFaillesTest.java | 321 +++++++++++++++++++++ 5 files changed, 775 insertions(+) create mode 100644 audit/00-SYNTHESE.md create mode 100644 audit/01-inventaire-triches.md create mode 100644 audit/02-failles-detection.md create mode 100644 audit/AVANCEMENT.md create mode 100644 audit/tests-proposes/AuditFaillesTest.java diff --git a/audit/00-SYNTHESE.md b/audit/00-SYNTHESE.md new file mode 100644 index 0000000..fe2a8a7 --- /dev/null +++ b/audit/00-SYNTHESE.md @@ -0,0 +1,69 @@ +# Synthèse de l'audit GastinelGarde 0.2.0 (2026-10-14) + +Détails : `01-inventaire-triches.md`, `02-failles-detection.md`, preuves : `tests-proposes/AuditFaillesTest.java` (17 tests verts dans une copie jetable). Rien n'a été modifié dans `src/`, rien n'est déployé. + +## Verdict +Le cœur (VL, paliers, exemptions, OBSERVE par défaut) est sain et testé. **Mais le mod ne doit pas passer en ENFORCE en l'état** : un bug de thread (F01) fait lever le timer sur tous les joueurs honnêtes, et plusieurs exemptions sont déclenchables par le client lui-même (riptide tenu, téléportation, dégâts, ping). Les contrôles actuels attrapent les triches grossières, pas un client réglé. + +## Les 5 failles à corriger en premier +| # | Faille | Pourquoi d'abord | Effort | +|---|---|---|---| +| 1 | **F01** : le HEAD du mixin s'exécute aussi sur le thread réseau (paquets comptés ×2) | Faux positif chez tous les joueurs ; état non thread-safe corrompu ; expulsion immédiate en ENFORCE | 0,5 h (garde `isSameThread`) | +| 2 | **F04** : trident Impulsion **en main** = seuil vanilla de 100 blocs/paquet et exemption totale du mouvement | Désactive la protection vanilla ET le mod avec un objet courant | 2-3 h (suivre l'utilisation réelle du trident, plafond physique) | +| 3 | **F05** : toute téléportation vanilla (dont « moved too quickly » provoqué) ouvre 2 s d'exemption | Un client peut s'exempter en continu | 2 h | +| 4 | **F07** : ping falsifiable = tous les seuils ×1,5 | Un module courant (PingSpoof) affaiblit tout | 1 h | +| 5 | **F14 + F19** : faux positifs d'atterrissage (élytres) et de grandes contraptions | Sans ça, la fiabilité sur ce serveur (Create, élytres, riptide) est nulle ; il faut avoir zéro fausse alerte avant ENFORCE | 3-4 h + essais | + +À suivre ensuite : F08 (vol aveugle), F02/F03 (timer), F11 (rotation silencieuse), F20 (véhicules). + +## Les 5 triches à ajouter en premier (phase 3 et suivantes) +| # | Contrôle | Idée | Estimation | +|---|---|---|---| +| 1 | **Balance de timer** (remplace `timer`) | Solde `+50 ms − delta réel` par paquet ; couvre 1,05x, blink, lag switch ; remise à zéro sur gel/téléportation | 1 soirée + rejeu | +| 2 | **Anti-knockback (velocity)** | Comparer le déplacement après chaque vélocité envoyée (dégâts, explosion, Wind Charge) à celle attendue ; sert aussi à corriger F06 et F14 | 1-2 soirées | +| 3 | **Reach et rotation** | Distance œil-boîte à chaque coup (vanilla tolère 4 blocs) ; snap de rotation avant coup contre la rotation silencieuse (F11) | 1 soirée | +| 4 | **Élytres** (déjà phase 3) | Modèle de plané : gain d'altitude ou de vitesse sans fusée ni riptide ; remplace l'exemption totale | 2-3 soirées | +| 5 | **Véhicules + marche sur l'eau** | Accrocher `handleMoveVehicle` ; plafond par milieu (Jesus, boat fly, NoSlow) | 2 soirées | + +Hors liste mais utile et peu coûteux : événements de blocs (nuker, fastbreak, scaffold : `BlockEvent.BreakEvent`, `PlayerInteractEvent`) : 2 soirées, valeur moyenne sur un serveur d'amis. + +## Ce qui ne pourra jamais être détecté côté serveur +Dit clairement : +- **X-ray, ESP, fullbright, freecam, zoom, minimap** : aucun paquet ne change. Seule une défense par masquage du contenu (AntiXray) agit, jamais par détection. Une heuristique de minage donne un soupçon statistique, pas une preuve. +- **Aimbot / triggerbot / autoclicker bien réglés** : indiscernables d'un joueur humain très bon, hors statistiques sur de longues sessions. +- **Safewalk, AutoTool, AutoSprint, AutoEat, étiquettes d'objets** : comportement identique à une action légitime. +- **Cartes et automatisation** (Baritone bien réglé) : trajectoire plausible. +- **Identité** : en `online-mode=false`, rien dans le comportement n'établit qui est derrière un pseudo. L'usurpation et le retour sous un autre pseudo ne se corrigent que par une authentification (online-mode, ou un second facteur de type mot de passe de session). +- **Un client sous le seuil** : tout seuil fixe se contourne par un client patient ; l'objectif réaliste (plan, section 5) est de bloquer les triches visibles, pas de rivaliser avec Grim. + +## Essais en jeu à faire par Théo (points [À VÉRIFIER]) +Client honnête = client vanilla/Fabric sans triche. Client de triche = celui de Théo. Garder tous les contrôles en OBSERVE, traces actives, lire `logs/gastinelgarde.log`. + +1. Client honnête : marcher et courir 20 s sur un terrain plat. **Attendu** : aucune ligne `timer` (si des lignes `timer` apparaissent à ~40 paquets/s, F01 est confirmé). +2. Client honnête avec un trident Impulsion en main (sans l'utiliser) : marcher 10 s. **Attendu** : ligne journal « riptide : seuil relevé » en debug ; confirme F04 (le seuil est relevé à tort). +3. Client de triche, module PingSpoof à 400 ms : courir à vitesse x1,5 (speed réglé juste au-dessus du seuil). **Attendu** : pas d'infraction avec ping 400, infraction avec ping 30 (F07). +4. Client honnête : voler en élytres avec fusée à pleine vitesse puis atterrir en marchant. **Attendu** : ligne `vitesse` à l'atterrissage (F14). +5. Client honnête : frapper une araignée ou un bébé zombie derrière une clôture, une trappe, un demi-bloc. **Attendu** : lignes `attaque-impossible` malgré le coup légitime (F18). +6. Client honnête sur un grand train ou une grande contraption Create (plus de 6 blocs de long), debout à l'extrémité, en mouvement. **Attendu** : lignes `vitesse` ou `vol` si F19 est réel ; relever `pocheContraption` dans la ligne (liste des exemptions). +7. Client de triche, module NoFall en mode « petit saut » ou équivalent, chute de 20 blocs : **Attendu** : dégâts de chute malgré `no-fall` OBSERVE ; noter si les dégâts sont absents (F22). Refaire avec `no-fall` en ENFORCE sur un seul joueur testeur. +8. Client honnête sur un dirigeable Aeronautics (monter, tourner, se déplacer à bord, descendre, marcher dessus à l'arrêt, atterrir) : **Attendu** : aucune ligne. Sinon, noter les noms de classe d'entités proches (`prefixesContraption`) et les exemptions listées (F25). +9. Client honnête : sprinter, sauter en courant, nager, glace, échelle, slime, riptide, perle, Wind Charge, puis chute. **Attendu** : aucune ligne (hors Wind Charge, signalé comme non géré). +10. Client honnête : combat contre 5 zombies ou un banc de poissons, 30 s. **Attendu** : aucune ligne `killaura-cibles` (sinon seuil de 3 cibles trop bas pour ce serveur). +11. Client de triche : killaura avec rotation silencieuse activée (« server-side rotation » ou « silent »), puis sans. **Attendu** : lignes `killaura-angle` uniquement sans la rotation silencieuse (F11). +12. Client de triche : fly en hover, puis hover avec un paquet tous les deux ticks (module de lag/timer à 0,5). **Attendu** : `vol` vu dans le premier cas seulement (F08). +13. Client de triche : timer à 1,05x puis 1,10x pendant 60 s, puis blink (retenir 5 s, relâcher). **Attendu** : rien (F03 confirmé) ; avec timer à 2x : `timer` vu. +14. Client de triche : tricher dans un bateau (boat fly, vitesse). **Attendu** : rien de la part du mod, seul vanilla (10 blocs/paquet) intervient (F20). +15. Un op : `/garde status`, `/garde mode vitesse enforce` puis `off`, `/garde reload`. **Attendu** : réponses correctes, fichier de configuration mis à jour. +16. Laisser les traces actives 24 h avec 2 joueurs : vérifier la taille du dossier `gastinelgarde-traces` (F15) ; **Attendu** : < 1 Go, sinon plafond non appliqué. + +## Résumé (10 lignes) +1. Le cœur est propre et testé ; le défaut majeur est à l'adaptateur : le mixin s'exécute aussi sur le thread réseau (F01), donc timer ×2, état corrompu. +2. Ne pas passer en ENFORCE avant F01, F04, F05, F07, F14. +3. Trident Impulsion tenu = 100 blocs/paquet autorisés et exemption totale (F04). +4. Grâce de téléportation et de dégâts : déclenchables par le client (F05, F06). +5. Ping falsifié = seuils ×1,5 (F07) ; vol aveugle si un paquet tous les 2 ticks (F08). +6. Fenêtres circulaires saturables : plus on envoie, moins c'est vu (F02, F12, F13). +7. Killaura à rotation silencieuse passe `killaura-angle` (F11) ; reach 3-4 blocs jamais mesuré. +8. Véhicules jamais contrôlés (F20) ; élytres exemptées en bloc. +9. Create et Aeronautics : exemption par proximité manquée pour les grandes structures et exploitable (F19, F25), à valider en jeu. +10. 17 tests de preuve dans `audit/tests-proposes/`, 16 essais en jeu listés ci-dessus. diff --git a/audit/01-inventaire-triches.md b/audit/01-inventaire-triches.md new file mode 100644 index 0000000..1c339c2 --- /dev/null +++ b/audit/01-inventaire-triches.md @@ -0,0 +1,135 @@ +# Étape 1 : inventaire des triches (1.21.1, serveur NeoForge `online-mode=false`) + +Audit du 2026-10-14. Lecture seule. GastinelGarde 0.2.0. + +## Sources (listes de fichiers lues, pas de mémoire) +- Meteor Client : `src/main/java/meteordevelopment/meteorclient/systems/modules/{combat,movement,player,world,misc}` et `movement/speed/modes`, `movement/elytrafly/modes` (via https://api.github.com/repos/MeteorDevelopment/meteor-client/contents/src/main/java/meteordevelopment/meteorclient/systems/modules/combat, `.../movement`, `.../player`, `.../world`, `.../misc`). +- Wurst : https://api.github.com/repos/Wurst-Imperium/Wurst7/contents/src/main/java/net/wurstclient/hacks (120 hacks listés : Killaura, KillauraLegit, MultiAura, TpAura, TriggerBot, Criticals, Reach, Flight, Glide, Jetpack, BoatFly, Spider, Step, Jesus, NoFall, SpeedHack, BunnyHop, Timer, Blink, NoClip, InvWalk, Nuker, SpeedNuker, FastBreak, FastPlace, Scaffold, XRay, Freecam, AutoSteal, AutoTotem, AutoArmor, CrashChest, ForceOp, KillPotion, MaceDmg, ExtraElytra…). +- LiquidBounce (nextgen) : https://api.github.com/repos/CCBlueX/LiquidBounce/contents/src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/{combat,movement,exploit} (killaura, backtrack, criticals, velocity, tickbase, timerrange, fakelag, hitbox, fly, speed, longjump, highjump, step, spider, noslow, liquidwalk, elytrafly, phase, `ModulePingSpoof`, `ModuleClip`, `ModuleTeleport`, `ModuleVehicleOneHit`, disabler, servercrasher, dupe…). +- Grim (liste des vérifications) : https://api.github.com/repos/GrimAnticheat/Grim/contents/common/src/main/java/ac/grim/grimac/checks/impl/{aim,badpackets,breaking,combat,crash,exploit,movement,multiactions,scaffolding,timer,velocity,misc} et dossiers `elytra, flight, groundspoof, packetorder, prediction, sprint, vehicle, baritone`. Wiki : https://github.com/GrimAnticheat/Grim/wiki/Checks. +- Vulcan, NoCheatPlus, Matrix, Spartan : **[À VÉRIFIER]** non consultés (plugins fermés ou dépôts non listés ici). Leurs catégories (fly, speed, reach, killaura, scaffold, nuker, nofall, timer, badpackets) recoupent la liste Grim ci-dessus, aucune catégorie nouvelle n'est affirmée sans source. +- Create Aeronautics : repose sur la bibliothèque **Sable** (« sub-levels », structures mobiles) selon https://modrinth.com/mod/aeroclaims ; aucun document sur l'anti-triche trouvé. Comportement des joueurs sur un sub-level : **[À VÉRIFIER]**. +- Code vanilla 1.21.1 cité : `net/minecraft/server/network/ServerGamePacketListenerImpl.java` (jar `build/moddev/artifacts/neoforge-21.1.234-sources.jar`). Lignes : `handleMovePlayer` 857, seuil « moved too quickly » 899-903, `resetFallDistance` si montée 960-961, `teleport` 1022-1038, `handleInteract` 1546-1558, vol interdit 263-273, `handleMoveVehicle` 389-410. + +## Rappel de ce que GastinelGarde voit +Un seul paquet de mouvement joueur (`handleMovePlayer`), l'événement `AttackEntityEvent`, `LivingDamageEvent.Post`, la téléportation vanilla. **Rien** sur : casse et pose de blocs, inventaire, utilisation d'objets (sauf « mange/boit »), véhicules (`handleMoveVehicle`), paquets de commandes (sprint, élytres), chat, signes, livres, paquets malformés, connexion. + +## Légende +- Couverte ? : `oui` (contrôle, fichier), `partiel`, `non`. +- Détectable côté serveur ? : `oui`, `partiel`, `non` + raison. +- Priorité = gravité sur un serveur de 5 amis × faisabilité : **P1** à **P3** (P1 = à faire en premier), `—` = ne vaut pas l'effort. + +## Combat + +| Catégorie | Triche | Ce qu'elle fait côté paquets | Couverte par GastinelGarde ? | Couverte par vanilla ? | Détectable côté serveur ? | Priorité | +|---|---|---|---|---|---|---| +| combat | Killaura (rotation visible) | Paquet d'attaque vers des entités proches, regard inchangé | partiel : `killaura-angle` (core/KillauraAngle.java) | non | oui : angle regard/cible | P2 | +| combat | Killaura (rotation silencieuse / « server-side rotation ») | Un paquet de rotation vers la cible juste avant chaque attaque | **non** : l'angle est alors ~0, `killaura-angle` ne voit rien | non | partiel : rotation instantanée de >90° en un tick, puis retour ; visible en trace | P1 | +| combat | Killaura multi-cibles / MultiAura / TpAura | Plusieurs entités frappées par tick ; TpAura se téléporte à la cible | partiel : `killaura-cibles` (core/CiblesMultiples.java, >3 en 1 s) ; TpAura non | non (reach 4 blocs seulement) | oui | P2 | +| combat | Reach / Hitboxes | Attaque d'une entité à 3,0–4,0 blocs (vanilla en tolère 4,0, `canInteractWithEntity(aabb, 1.0)`) | **non** (aucune mesure de distance) | partiel : refus au-delà de ~4 blocs (ServerGamePacketListenerImpl:1558) | oui : distance œil-boîte au moment du coup | P1 | +| combat | Triggerbot | Attaque dès que le curseur croise une cible, regard légitime | non | non | partiel : temps de réaction, seulement par statistique | P3 | +| combat | Aimbot / AimAssist | Rotations lissées vers la cible | non | non | partiel : statistiques de rotation (Grim `aim`) | P3 | +| combat | Autoclicker / cadence | Plus de 15-20 attaques par seconde | oui : `cadence`, `regularite` (core/Cadence.java) ; limité à 64 cps (fenêtre de 128) | partiel : le recharge réduit les dégâts, pas les coups | oui | P3 | +| combat | NoMissCooldown / sans recharge | Attaques avant fin du recharge, dégâts pleins via exploit | non | oui (recharge) | oui | — | +| combat | Criticals | Faux `onGround=false` + petits sauts de 0,0625 avant le coup | **non** | non | oui : attaque après y+0,0625 sans saut réel (Grim a des contrôles de mouvement, pas un « criticals » dédié) | P2 | +| combat | Velocity / AntiKnockback | Ignore le recul : le client ne bouge pas après le paquet de vélocité | **non** : seule une exemption de 1 s après dégât | non | oui : comparer le mouvement réel à la vélocité envoyée (Grim `velocity/KnockbackHandler`) | P1 | +| combat | Backtrack / FakeLag / TickBase / TimerRange | Retarde et libère les paquets pour frapper « dans le passé » | non | non | partiel : bursts de paquets (balance du timer) | P3 | +| combat | SuperKnockback / KeepSprint | Renvoi sprint pour plus de recul | non | non | non fiable | — | +| combat | AutoCrystal / AnchorAura / BedAura / Surround / Burrow | Automatisation du PvP à base de cristaux | non | non | non utile : serveur PvE entre amis | — | +| combat | BowAimbot / BowSpam / AutoShoot | Tir instantané ou aimbot | non | partiel : temps de charge de l'arc | partiel | P3 | +| combat | MaceDmg / MaceKill / Hitbox (Wurst, LiquidBounce) | Fausse hauteur de chute pour dégâts de masse | non | non | oui : hauteur de chute déclarée vs vue du serveur | P2 | +| combat | AutoTotem / Offhand / AutoArmor / AutoWeapon | Échanges d'inventaire en un tick | non | non | partiel : cadence d'actions d'inventaire (Grim `multiactions`) | P3 | + +## Mouvement + +| Catégorie | Triche | Ce qu'elle fait côté paquets | Couverte ? | Vanilla ? | Détectable ? | Priorité | +|---|---|---|---|---|---|---| +| mouvement | Fly (Velocity / abilities / creative-fly) | Hover : dy≈0 ; `abilities.flying` ignoré par le serveur | partiel : `vol` (core/VolVertical.java, modèle de gravité). **Aveugle si ≠ 1 paquet par tick** | oui : kick « flying » après 80 ticks si dy ≥ -0,03125 (ServerGamePacketListenerImpl:263-273) | oui | P1 | +| mouvement | Fly avec « anti-kick » (descente 0,03125 périodique) | Contourne le kick vanilla par un petit pas vers le bas | partiel : `vol` voit le hover >10 ticks | contourné | oui | P2 | +| mouvement | Glide / Jetpack | Chute lente constante ou poussée à la demande | partiel : `vol` (plané lent) | non | oui | P2 | +| mouvement | Speed / BunnyHop / Strafe | Vitesse horizontale > 0,28 blocs/tick | partiel : `vitesse` (core/VitesseHorizontale.java) ; seuil généreux + exemptions glace/âmes/slime | non (10 blocs/paquet) | oui (précision limitée) | P1 | +| mouvement | Timer (accélération) | 22–40 paquets/s | partiel : `timer` (core/TimerPaquets.java) ; ne voit pas 1,05–1,10× ni les bursts | non | oui : balance cumulée (Grim `timer/Timer, TickTimer, NegativeTimer`) | P1 | +| mouvement | Blink / FakeLag / Freeze | Retient les paquets puis les libère en rafale | **non** (fenêtre 1 s, 3 s soutenues) | non | partiel : balance cumulée ; fausse alerte avec lag | P2 | +| mouvement | NoFall | `onGround=true` en chute ; ou petit saut avant l'impact | partiel : `no-fall` (core/NoFall.java), corrige seulement en ENFORCE ; saut de 0,01 → `resetFallDistance` vanilla :960 **[À VÉRIFIER]** | non | oui | P1 | +| mouvement | Step / ReverseStep / HighJump / LongJump | Montée > 0,6 ou saut démesuré en un paquet | partiel : seulement via `vol` (>10 ticks) ; une marche de 1,5 bloc en un paquet est invisible | non (10 blocs) | oui : dy d'un seul tick ≥ 0,6 hors saut | P2 | +| mouvement | Spider / FastClimb / AirJump | Monte le long d'un mur, ou re-saute en l'air | partiel : `vol` ; mur « échelle » exempté par `onClimbable` | non | oui | P2 | +| mouvement | Jesus / LiquidWalk / Dolphin | Marche sur l'eau | **non** : eau et lave exemptées entièrement (`milieuSpecial`) | non | oui : `onGround` client sur un liquide | P2 | +| mouvement | NoSlow | Pas de ralentissement en mangeant / bloquant / toile / miel | **non** : `ralentiParObjet` ne sert qu'à abaisser le seuil | non | oui (Grim `movement/NoSlow`) | P2 | +| mouvement | NoClip / Phase / Freecam-clip | Traverse les blocs | partiel : vanilla annule si « moved wrongly » en bloc plein | oui, partiel (ServerGamePacketListenerImpl:920-940 ; le test vertical est inopérant : `d7 > -0.5 \|\| d7 < 0.5` est toujours vrai, d7 = 0) | oui | P2 | +| mouvement | Teleport / ClickTP / Clip / vclip | Saut instantané de 5–100 blocs | partiel : vanilla ~10 blocs/paquet ; **100 blocs si trident Impulsion en main** (RiptideMoveMixin) | oui, 10 blocs | oui | P1 | +| mouvement | Elytra fly / ElytraBoost / Bounce / Pitch40 / ExtraElytra | Vitesse et altitude sans fusée | **non** (`elytres` exempte tout) | partiel : 300 par paquet (:899) | partiel : modèle de plané (phase 3) | P1 | +| mouvement | Boat fly / EntityControl / VehicleBoost / VehicleControl | Mouvement de véhicule (`ServerboundMoveVehiclePacket`) | **non** : `handleMoveVehicle` jamais accroché | partiel : 10 blocs/paquet (:410) | oui | P2 | +| mouvement | Safewalk / Parkour / AutoJump / Sneak | Évite le vide, saute au bord | non | non | non (indiscernable d'un joueur) | — | +| mouvement | Sprint (omni, AutoSprint) | Sprint dans toutes les directions | non | non | partiel (Grim `sprint`) | P3 | +| mouvement | InventoryMove / GUIMove / InvWalk | Marche avec l'inventaire ouvert | non | non | oui : mouvement avec fenêtre ouverte (le serveur sait quelle fenêtre est ouverte) | P3 | +| mouvement | AntiVoid / Anchor | Rattrape sous le vide ; s'accroche | non | non | partiel | — | +| mouvement | Baritone / AutoWalk / pathfinding | Marche automatique parfaite | non | non | partiel : trajectoires trop régulières (Grim `baritone`) | — | +| mouvement | Perle / vélocité de fusée spoofée | Utilise la grâce « téléportation » | **exploite** la grâce de 2 s (voir audit 02) | — | — | — | + +## Monde + +| Catégorie | Triche | Ce qu'elle fait côté paquets | Couverte ? | Vanilla ? | Détectable ? | Priorité | +|---|---|---|---|---|---|---| +| monde | X-ray / CaveFinder / NewChunks / ESP | Aucun paquet : rendu client modifié | non (AntiXray 1.4.8 installé, sans effet constaté) | non | **non** par comportement ; oui par masquage des minerais (AntiXray) | P2 | +| monde | Freecam / RemoteView / CameraNoClip | Caméra libre, aucun paquet | non | non | **non** | — | +| monde | Nuker / SpeedNuker / VeinMiner / Excavator | Casse plusieurs blocs par tick, hors ligne de vue | **non** | partiel : distance de casse 6 blocs | oui : casses/tick, angle, ligne de vue (Grim `breaking/*`) | P2 | +| monde | FastBreak / SpeedMine / InstantRebreak / PacketMine | Finit de casser trop tôt | **non** | partiel : vitesse de casse validée côté serveur (`ServerPlayerGameMode`) | oui (Grim `breaking/FastBreak`) | P2 | +| monde | FastPlace / AirPlace / Scaffold / Tower / Tillaura | Pose de blocs en l'air, très vite, sans viser | **non** | partiel : faces valides, portée | oui (Grim `scaffolding/*`) | P2 | +| monde | GhostHand / NoMiningTrace / LiquidInteract | Interagit à travers des blocs | non | partiel | oui (lancer de rayon serveur) | P3 | +| monde | Reach de casse / pose (BuildHeight, Reach) | Portée > 4,5 | non | partiel : 6 blocs (:distance) | oui | P3 | +| monde | AutoTool / AutoSword | Change d'outil juste avant l'action | non | non | non (indiscernable) | — | +| monde | Timer exploits sur la casse (TickBase) | Casse accélérée par timer | via `timer` | non | oui | — | + +## Joueur et inventaire + +| Catégorie | Triche | Ce qu'elle fait côté paquets | Couverte ? | Vanilla ? | Détectable ? | Priorité | +|---|---|---|---|---|---|---| +| joueur | FastUse / FastEat / BowSpam | Termine l'utilisation d'objet avant la durée | partiel : « attaque en mangeant » seulement | oui (durée côté serveur pour manger) | oui | P3 | +| joueur | AutoEat / AutoGap / AutoPotion | Utilise des objets automatiquement | non | non | non | — | +| joueur | AntiHunger | `onGround=false` en sprintant → pas de faim | non | non | partiel (Grim n'a pas de contrôle dédié) | P3 | +| joueur | NoRotate / Derp / HeadRoll / pitch hors limites | Rotations impossibles (|pitch|>90) | non | oui : pitch borné (`Mth.clamp`) | oui | — | +| joueur | AutoSteal / ChestStealer / Restock / AutoDrop | Vide un coffre en un tick, en rafale | non | non | oui : clics de conteneur par tick (Grim `multiactions`) | P3 | +| joueur | Fakeplayer / NameProtect | Client uniquement | non | non | non | — | +| joueur | PingSpoof (LiquidBounce `ModulePingSpoof`) | Retarde les réponses de keep-alive : ping affiché élevé | **exploite** `pingLagMs` : tolérance ×1,5 sur tous les seuils (audit 02) | non | oui : ping très variable, ou ping élevé sans perte | P1 | + +## Réseau, crash, exploits de contenu + +| Catégorie | Triche | Ce qu'elle fait côté paquets | Couverte ? | Vanilla ? | Détectable ? | Priorité | +|---|---|---|---|---|---|---| +| réseau | Packet spam / flood | Des centaines de paquets par seconde | partiel : `timer` seulement pour le mouvement, et pas au-delà de 512 | partiel : `rate-limit` du serveur (désactivé par défaut) **[À VÉRIFIER]** | oui | P2 | +| réseau | Crash exploits (CrashChest, servercrasher, NBT géants, signes, `CrashA..I` Grim) | Paquets ou NBT surdimensionnés, containers malformés | non | partiel (limites réseau) ; dépend des mods installés | oui, par limites de taille ; mais plutôt un travail de correctifs de mods | P2 | +| réseau | Book ban / Book exploit (BookBot) | Livres à pages énormes | non | partiel | oui | P3 | +| réseau | Désynchronisation / ghost blocks | Placement sur un bloc fantôme | non | non | partiel (Grim `GhostBlockMitigation`) | — | +| réseau | Duplication (LiquidBounce `dupe`) | Exploit de logique de conteneurs | non | selon version | non par anti-triche ; correctif de version | P3 | +| réseau | Disabler (LiquidBounce `disabler`) | Désactive les contrôles d'un anti-triche précis | non | — | partiel | — | +| réseau | Plugin / mod scanner (`ModulePlugins`) | Découvre la configuration du serveur | non | — | non | — | +| réseau | ForceOp / commandes | Tentative `/op` | non (les ops sont gérés par vanilla) | oui | oui | — | +| réseau | Spoof de marque client (ClientBrand, ServerSpoof) | Faux nom de client | non (et à ne pas utiliser, plan D13) | — | **non** (falsifiable) | — | + +## Triches propres au serveur + +| Catégorie | Triche | Ce qu'elle fait | Couverte ? | Vanilla ? | Détectable ? | Priorité | +|---|---|---|---|---|---|---| +| Create | Marche sur une contraption comme sur une zone exemptée (« Create sert d'excuse ») | Reste à moins de 3 blocs d'une entité Create pour être exempté du combat et du mouvement | **exploitable** : exemption pure par proximité (audit 02) | — | oui : vérifier que la contraption bouge réellement, ou que le joueur est passager/sur un bloc de la structure | P1 | +| Create | Contraptions comme arme (drill, saw, deployer) hors claim | Dégâts sans joueur | non (GastinelClaims) | — | via claims | P3 | +| Create | Duplication par contraptions / pistons | Duplication d'objets | non | — | non (correctif du mod) | P3 | +| Aeronautics | Vol « normal » sur dirigeable (sub-level Sable) | Position joueur transportée par la physique, sans paquets de mouvement joueur | exempté si une entité est à ≤ 3 blocs (préfixes `dev.simulated_team`, `dev.ryanhcode`) **[À VÉRIFIER]** | — | non fiable tant qu'on ne sait pas comment le joueur est porté | P1 (fausses alertes) | +| Aeronautics | Contraption volée + téléportation de blocs | Déplacement de structure par commandes ou bug | non | — | partiel | — | +| hors-ligne | Usurpation de pseudo (`online-mode=false`) | Se connecter avec le pseudo d'un autre joueur whitelisté | **non** (README : limite connue) | partiel : whitelist par pseudo seulement | **non par comportement** ; oui par `online-mode=true`, ou un mot de passe de session (GastinelAuth ?) **[À VÉRIFIER]** | P1 | +| hors-ligne | Contournement d'expulsion par un autre pseudo | Revenir sous un pseudo de la whitelist | non (limite connue) | non | oui : corrélation d'empreintes (IP, UUID hors-ligne) | P2 | +| hors-ligne | Ban evasion par changement d'UUID | UUID hors-ligne dérivé du pseudo | non | non | partiel | P3 | + +## Les 10 triches non couvertes les plus importantes (classement) + +1. **Usurpation de pseudo / compte** (`online-mode=false`) : le pire cas du plan (T1) ; une porte d'entrée pour tout le reste. Hors du périmètre d'un anti-triche de mouvement. +2. **Ping spoof et lag** pour élargir les seuils : annule une partie des contrôles existants (facteur ×1,5 constaté dans `Exemptions.java:51-53`). +3. **Anti-knockback / velocity** : aucune mesure ; très courant, et détectable. +4. **Reach 3-4 blocs** : vanilla autorise 4 blocs ; aucun contrôle de distance. +5. **Killaura à rotation silencieuse** : passe `killaura-angle` ; ajouter un contrôle de rotations brusques et de « snap ». +6. **Elytra fly / vitesse en élytres** : exemption totale ; phase 3. +7. **Blink / balance de timer** : fenêtre de 1 s, rafales invisibles. +8. **Véhicules** (boat fly, vitesse de monture) : aucun hook sur `handleMoveVehicle`. +9. **Jesus / marche sur l'eau et NoSlow** : eau et milieux spéciaux exemptés d'office. +10. **Nuker / FastBreak / Scaffold** : aucune écoute des événements de bloc. + +Hors classement car non détectables : voir `00-SYNTHESE.md`. diff --git a/audit/02-failles-detection.md b/audit/02-failles-detection.md new file mode 100644 index 0000000..0ca14f6 --- /dev/null +++ b/audit/02-failles-detection.md @@ -0,0 +1,234 @@ +# Étape 2 : failles de détection de GastinelGarde 0.2.0 + +Audit du 2026-10-14. Lecture seule. Tests : `audit/tests-proposes/AuditFaillesTest.java`, **17 tests verts** lancés dans une copie jetable (hors `src/`). Un test « BYPASS » ou « FAUX_POSITIF » est vert tant que la faille existe, et passera au rouge une fois corrigée. +Vanilla cité : `net/minecraft/server/network/ServerGamePacketListenerImpl.java` du jar `build/moddev/artifacts/neoforge-21.1.234-sources.jar` (lignes de ce fichier). + +Chemins : `core/` = `src/main/java/com/gastinelgarde/core/`. + +## Résumé par gravité + +| Id | Contrôle | Gravité | Type | +|---|---|---|---| +| F01 | timer (mixin) | **critique** | bug + faux positif | +| F04 | riptide / vitesse vanilla | **critique** | contournement | +| F07 | tous (ping) | élevée | contournement | +| F05 | vitesse, vol, timer (grâce téléportation) | élevée | contournement | +| F08 | vol | élevée | contournement | +| F11 | killaura-angle | élevée | contournement | +| F14 | vitesse (atterrissage élytres) | élevée | faux positif | +| F19 | vitesse, vol, combat (Create) | élevée | faux positif [À VÉRIFIER] | +| F20 | véhicules | élevée | trou de couverture | +| F02 | timer | moyenne | contournement | +| F03 | timer | moyenne | contournement | +| F06 | vitesse, vol (grâce dégâts) | moyenne | contournement | +| F09 | vitesse | moyenne | contournement | +| F10 | vitesse | moyenne | contournement | +| F12 | cadence | moyenne | contournement | +| F18 | attaque-impossible | moyenne | faux positif | +| F21 | état par joueur | moyenne | bug (concurrence, fuite) | +| F22 | no-fall | moyenne | contournement [À VÉRIFIER] | +| F15 | traces | moyenne | bug | +| F13 | killaura-cibles | faible | contournement | +| F16 | VL | faible | bug | +| F17 | vitesse | faible | contournement | +| F23 | configuration | faible | bug (concurrence) | +| F24 | mixins | moyenne | fragilité | +| F25 | Aeronautics | élevée | faux positif [À VÉRIFIER] | + +--- + +## F01 : le mixin tourne aussi sur le thread réseau, chaque paquet est compté deux fois +- **Contrôle** : `timer` (et tout ce que `avantMouvement` touche). +- **Gravité** : critique. **Type** : bug (concurrence) + faux positif. +- **Description** : `MovePacketMixin.gastinelgarde$avantMouvement` est injecté en `HEAD` de `handleMovePlayer`. La première instruction vanilla est `PacketUtils.ensureRunningOnSameThread(...)` (ServerGamePacketListenerImpl:858). Sur le thread réseau, cet appel replanifie le paquet sur le thread serveur puis lance une exception : le `HEAD` s'est donc déjà exécuté **une première fois sur le thread Netty**, puis une seconde fois sur le thread serveur (`PacketUtils.java:21-38`). Conséquences : + 1. `TimerPaquets` voit **40 paquets/s** pour un joueur honnête à 20/s (seuil 22 sur 3 s) : une infraction à chaque paquet, +1 à +3,8 points, VL 20 en quelques secondes, **expulsion en ENFORCE**, alertes aux ops en continu en OBSERVE. + 2. `Moteur`, `Suivi`, `Fenetre` (non thread-safe, Moteur.java:15) et `Garde.MARQUES` (`HashMap.computeIfAbsent`) sont modifiés par deux threads : corruption possible, `ConcurrentModificationException`. + 3. `appliquerSanctionMouvement` (`connection.teleport`, `disconnect`) peut partir du thread réseau. +- **Preuve** : test `F01_timer_paquet_compte_deux_fois_faux_positif` (compter deux fois = infraction ; une fois = rien). Le fait que le HEAD s'exécute sur Netty vient du code vanilla ci-dessus (non testable sans le jeu : `[À VÉRIFIER]` en jeu, voir synthèse essai 1). La ligne de journal attendue : `timer ... vl=...` dès 3 s de marche. +- **Correction proposée** : dans `gastinelgarde$avantMouvement`, sortir si `!player.server.isSameThread()` (ou injecter `@At(value="INVOKE", target="...PacketUtils;ensureRunningOnSameThread", shift=AFTER)`). Ajouter un `assert` de thread dans `Moteur` en développement. +- **Risque** : faible ; le temps mesuré devient celui du thread serveur (traitement groupé après un gel), déjà géré par la grâce de gel. + +## F02 : inondation de paquets, le timer devient aveugle +- **Contrôle** : `timer`. **Gravité** : moyenne. **Type** : contournement. +- **Description** : `TimerPaquets` utilise `Fenetre(512)` (core/TimerPaquets.java:9). Au-delà d'environ 512 paquets/s, 512 entrées ne couvrent plus 2 s : le compte de la seconde k=1 vaut 0 et `enregistrer` renvoie 0 (ligne 20). Plus on envoie de paquets, moins on est vu. +- **Preuve** : `F02_timer_inondation_BYPASS` (1000 paquets/s : aucune infraction ; 100/s : vu). +- **Correction** : compter par compteur de seconde (tableau de 4 entiers par tranche de 250 ms) au lieu d'un tampon d'événements ; ou plafonner : tout débit > capacité/2 = infraction maximale immédiate. +- **Risque** : faible. + +## F03 : timer faible (1,1x) et rafales (blink) +- **Contrôle** : `timer`. **Gravité** : moyenne. **Type** : contournement. +- **Description** : le seuil est strictement `> 22` paquets/s (soit 1,10x). Un timer à 1,05-1,10x gagne 10 % de vitesse et de cadence sans infraction. Une rafale après un silence (blink, lag switch) n'est jamais soutenue 3 s. Grim utilise une **balance cumulée** (`checks/impl/timer/Timer`, `NegativeTimer`). +- **Preuve** : `F03_timer_faible_et_blink_BYPASS`. +- **Correction** : balance : `solde += 50 ms - delta_réel` par paquet, plafonnée ; infraction si `solde > +150 ms` (paquets en avance sur l'horloge). Remise à zéro sur gel, déconnexion, téléportation. Test rejouable en JUnit. +- **Risque** : moyen (lag réseau honnête : les rafales de rattrapage). Démarrer en OBSERVE avec les traces. + +## F04 : tenir un trident Impulsion neutralise tout le mouvement +- **Contrôle** : `RiptideMoveMixin`, `vitesse`, `vol`, `no-fall`. **Gravité** : critique. **Type** : contournement. +- **Description** : `gastinelgarde$seuil` passe `riptide=true` dès qu'un trident Impulsion est **en main** (RiptideMoveMixin.java:211-214). Le seuil vanilla « moved too quickly » (100, soit 10 blocs/paquet) devient 10 000 (**100 blocs/paquet**, 2 000 blocs/s). En plus `Garde.etat` (Garde.java:193) positionne `riptide`, ce qui exempte toute la famille mouvement pendant 2 s après. Tenir un trident = téléportation, vol et vitesse libres. Le seuil élytres (300) est relevé de la même façon. +- **Preuve** : `F04_riptide_tenu_seuil_vanilla_neutralise_BYPASS` (la partie « en main » est dans le mixin, non testable sans le jeu ; le calcul est testé). +- **Correction** : ne relever le seuil qu'après une **utilisation réelle** : suivre `LivingEntityUseItemEvent.Stop` (trident Impulsion, charge ≥ 10 ticks) ou `isAutoSpinAttack()`, puis une fenêtre de 40 ticks. Remplacer 10 000 par la distance maximale physique (élan 3 blocs/tick × 20 ticks = 60) ou par une vérification a posteriori. +- **Risque** : moyen. Le serveur ne lance la vrille que s'il juge l'eau ou la pluie (commentaire du mixin) : bien tester les retours en arrière du 13/10. + +## F05 : toute téléportation vanilla ouvre 2 s d'exemption, déclenchable par le client +- **Contrôle** : `vitesse`, `vol`, `timer`, `no-fall`. **Gravité** : élevée. **Type** : contournement. +- **Description** : `MovePacketMixin` marque une téléportation à **chaque** `teleport()` (ligne 153). Vanilla appelle `teleport()` pour « moved too quickly » (:904) et pour « moved wrongly » (:~963). Un client envoie un paquet volontairement trop rapide toutes les 1,9 s : vanilla le ramène (aucun gain pour lui), et GastinelGarde l'exempte 40 ticks de mouvement et de timer. Idem pour le setback du mod lui-même. +- **Preuve** : `F05_grace_teleportation_rechargee_en_boucle_BYPASS` (20 blocs/s soutenus pendant 30 s, aucune infraction). +- **Correction** : ne marquer que les téléportations **non provoquées** par le client : distinguer par l'appelant (`teleport` appelé depuis `handleMovePlayer` = refus vanilla, ne pas marquer ; ou ne marquer que si le déplacement serveur est > 4 blocs depuis la dernière position acceptée). Raccourcir la grâce à 10 ticks pour les téléportations internes. +- **Risque** : moyen (téléportation légitime non marquée = fausse alerte ; garder le marquage pour `/tp`, perle, TPA, dimension). + +## F06 : tout dégât exempte le mouvement +- **Contrôle** : `vitesse`, `vol`. **Gravité** : moyenne. **Type** : contournement. +- **Description** : `LivingDamageEvent.Post` (GardeEvents.java:82-85) marque un « recul » pour **tout** dégât, 20 ticks de grâce (`<=`, borne incluse). Feu, cactus, baies, faim, poison, wither : un dégât par seconde suffit à être exempté en permanence. Aussi, l'événement ne dit pas si un recul a eu lieu. +- **Preuve** : `F06_grace_degats_BYPASS`. +- **Correction** : marquer seulement si une **vélocité** a été envoyée au joueur (`ClientboundSetEntityMotionPacket` pour lui, ou `LivingKnockBackEvent`/explosion), et mesurer la vélocité attendue (anti-knockback). +- **Risque** : faible à moyen. + +## F07 : le ping falsifié multiplie tous les seuils par 1,5 +- **Contrôle** : tous (`Exemptions.java:51-53`). **Gravité** : élevée. **Type** : contournement. +- **Description** : `lag = tps < 18 || ping > 250 ms` → `facteur 1,5`. Le ping vient de `connection.latency()` (réponses aux keep-alive), donc **retardé par le client** (module `PingSpoof` de LiquidBounce, `ModulePingSpoof.kt`). 1,5 s de réponse tardive = seuils élargis en continu : vitesse 0,45 au sol, 30 coups/s, 4 cibles, 90° d'angle, 33 paquets/s. +- **Preuve** : `F07_ping_spoof_elargit_les_seuils_BYPASS`. +- **Correction** : ne pas accorder de facteur sur le ping seul : exiger un ping élevé **et** un TPS serveur bas, ou ne tolérer que les rafales ; plafonner le facteur à 1,15 pour le ping, 1,5 pour le TPS. Journaliser la variance du ping (ping très élevé constant sans perte = suspect). +- **Risque** : faible (plus de fausses alertes pour un joueur honnête en wifi médiocre : à mesurer dans les traces). + +## F08 : le contrôle de vol ne s'évalue que si `ticks == 1` +- **Contrôle** : `vol` (core/VolVertical.java:28-31). **Gravité** : élevée. **Type** : contournement. +- **Description** : `if (e.ticks() != 1) { aVitesse=false; return 0; }`. Un client qui envoie un paquet tous les 2 ticks (ou 2 par tick) n'est jamais évalué. Sur le thread serveur, le jitter honnête (paquets traités à cheval sur deux ticks) rend aussi l'évaluation intermittente. +- **Preuve** : `F08_vol_aveugle_si_ticks_different_de_1_BYPASS`. +- **Correction** : modéliser sur le temps cumulé : appliquer la prédiction `ticks` fois (`vy' = (vy-0,08)*0,98` itéré), et accepter une tolérance proportionnelle à `ticks`. +- **Risque** : moyen (recalibrer avec les traces). + +## F09 : rester sous le tampon de vitesse +- **Contrôle** : `vitesse`. **Gravité** : moyenne. **Type** : contournement. +- **Description** : bornes : 0,30 sprint au sol (vanilla ~0,28), 0,42 en l'air ; tampon de 1,5 bloc sur 20 ticks = +0,075 bloc/tick. Soutenu : 0,375 au sol (+34 %) ou 0,495 en l'air (+18 % sur COURSE_SAUT) sans infraction. Ajouté au facteur ping (F07) : 0,56/0,74. +- **Preuve** : `F09_vitesse_sous_le_tampon_BYPASS` (0,37 au sol et 0,49 en l'air, 60 s). +- **Correction** : après les traces honnêtes, resserrer `COURSE` à 0,29, `COURSE_SAUT` à 0,37 ; passer le tampon à 0,5-0,8 bloc et accumuler sur 40 ticks avec décroissance plus lente que 0,5/s. +- **Risque** : élevé (fausses alertes) : seulement avec les traces du joueur honnête et de la glace. + +## F10 : milieux spéciaux et friction anormale ignorés totalement +- **Contrôle** : `vitesse` (core/VitesseHorizontale.java:41-45), `Garde.milieuSpecial/frictionAnormale`. **Gravité** : moyenne. **Type** : contournement. +- **Description** : dans l'eau, sur glace, âmes, slime, miel, échelle, ou vol créatif : excès = 0, quelle que soit la vitesse (3 blocs/tick passe). Jesus, Speed sur glace et marche aquatique sont invisibles. Aussi, « sous le joueur » utilise le bloc à 0,5 sous la position : un bloc de glace posé sous soi permet d'être exempté. +- **Preuve** : `F10_milieux_exemptes_totalement_BYPASS`. +- **Correction** : au lieu d'ignorer, appliquer un **plafond absolu par milieu** (eau : 0,2 ; glace : 0,9 ; bulle : 0,6) et ne pas exempter le premier contact (poser de la glace). Vérifier que l'état est vrai sur plusieurs ticks. +- **Risque** : moyen. + +## F11 : killaura à rotation silencieuse +- **Contrôle** : `killaura-angle`. **Gravité** : élevée. **Type** : contournement. +- **Description** : l'angle est mesuré avec le regard serveur à la réception du coup. Un client qui envoie un paquet de rotation vers la cible juste avant chaque attaque (« server-side rotation ») donne un excédent de 0°. Le seuil est en outre large : centre de boîte à 60° + demi-angle de la sphère englobante (jusqu'à ~20° à 3 blocs pour un joueur) ≈ 80°. +- **Preuve** : `F11_killaura_rotation_silencieuse_BYPASS`. +- **Correction** : ajouter un contrôle **de rotation** : écart d'angle entre deux paquets > 60° en un tick puis retour (snap) + coup dans le même tick ; vitesse de rotation avant le coup ; coups sur deux cibles espacées de > 90° en < 3 ticks. Utiliser aussi l'écart avec le **dernier regard vu avant** le paquet de rotation. +- **Risque** : moyen (les joueurs honnêtes font des tours rapides : seuils à régler avec les traces). + +## F12 : cadence saturée +- **Contrôle** : `cadence` (core/Cadence.java:14,21-23). **Gravité** : moyenne. **Type** : contournement. +- **Description** : `Fenetre(128)` : à plus de 128 coups/s, les 128 entrées tiennent dans moins d'une seconde, `precedent` vaut 0. 200 coups/s ne lèvent rien. Paradoxe : plus c'est rapide, moins c'est vu. Vanilla ne limite pas le nombre de paquets d'attaque par tick. +- **Preuve** : `F12_cadence_saturation_BYPASS` (40/s vu, 200/s non). +- **Correction** : compteurs par tranche de 50 ms (ticks) sur 40 ticks ; plafond absolu `> 3 coups/tick` = infraction immédiate. +- **Risque** : faible. + +## F13 : la fenêtre des cibles est saturable +- **Contrôle** : `killaura-cibles` (core/CiblesMultiples.java:6). **Gravité** : faible. **Type** : contournement. +- **Description** : `Fenetre(32)`. 8 coups/tick sur une cible chassent les autres cibles de la fenêtre : 5 entités par seconde passent. Peu réaliste face à un vrai killaura (qui respecte le recharge), mais prouvé. +- **Preuve** : `F13_cibles_multiples_fenetre_saturable_BYPASS`. +- **Correction** : mémoriser les identifiants distincts par seconde (ensemble de taille bornée) au lieu des 32 derniers coups. +- **Risque** : faible. + +## F14 : atterrissage rapide après élytres : faux positif +- **Contrôle** : `vitesse`. **Gravité** : élevée. **Type** : faux positif. +- **Description** : `elytres` exempte tant que `isFallFlying()`. Dès l'atterrissage, l'élan (1,0-1,7 bloc/tick) est jugé contre `COURSE` 0,30 : excès cumulé > 1,5 en quelques ticks. Pas de grâce après les élytres (contrairement au riptide, 40 ticks). Même chose après Wind Charge, mace, piston, slime, explosion sans dégâts (non gérés, README). +- **Preuve** : `F14_atterrissage_elytres_faux_positif` (1,7 bloc/tick amorti de 0,546 par tick au sol). +- **Correction** : grâce de 20-40 ticks après `isFallFlying` passé à faux, et après toute vélocité reçue (voir F06). +- **Risque** : faible. + +## F15 : plafond de taille des traces non appliqué dans la journée +- **Contrôle** : traces (core/TraceFichier.java:44-49, 82-109). **Gravité** : moyenne. **Type** : bug. +- **Description** : la purge n'a lieu qu'à l'ouverture d'un nouveau fichier (changement de jour UTC) et elle **saute le fichier du jour** (ligne 104). Avec environ 10 Mo par heure et par joueur, 5 joueurs et enregistrement continu, le fichier du jour atteint 1 Go en 20 h sans purge. Aucune alerte disque. +- **Preuve** : `F15_traces_plafond_non_applique_dans_la_journee` (plafond 1 Ko, fichier de 2 Mo). +- **Correction** : purger toutes les 5 min (ou tous les 10 000 écritures) et permettre la rotation par taille (`trace-JJ-1.jsonl`) ; couper les traces proprement si l'espace libre du disque est < 5 Go. +- **Risque** : faible. + +## F16 : décroissance des VL figée à la création du suivi +- **Contrôle** : `VlCompteur`. **Gravité** : faible. **Type** : bug. +- **Description** : `Suivi(cfg.vlDecroissanceParSeconde)` copie la valeur à la création (Moteur.java:34). `/garde reload` ou le fichier ne l'appliquent qu'aux joueurs qui se reconnectent (documenté dans `GardeSpec`, mais surprenant). +- **Preuve** : `F16_decroissance_figee_a_la_creation`. +- **Correction** : passer `cfg` au compteur et lire la valeur à chaque calcul. +- **Risque** : nul. + +## F17 : une rafale par seconde sous le tampon +- **Contrôle** : `vitesse`. **Gravité** : faible. **Type** : contournement. +- **Description** : un déplacement de 1,7 bloc en un tick toutes les secondes (1,4 de dépassement) reste sous 1,5 : +25 blocs/min gratuits, soit un « blink » discret ou un petit teleport régulier. Combiné à F05 (grâce rechargée par vanilla), non limité. +- **Preuve** : `F17_tampon_vitesse_rafale_isolee_BYPASS`. +- **Correction** : plafond par tick absolu (ex. 1,0 bloc/tick hors exemption = infraction directe) en plus du tampon. +- **Risque** : moyen (téléportations non marquées). + +--- + +## Failles non testables sans le jeu + +## F18 : `attaque-impossible` utilise une ligne de vue œil à œil +- **Contrôle** : `attaque-impossible` (GardeEvents.java:65, `p.hasLineOfSight(cible)`). **Gravité** : moyenne. **Type** : faux positif. +- **Description** : `hasLineOfSight` trace œil du joueur → œil de la cible. Un coup légitime sur le corps ou les pieds d'un mob derrière une clôture, une trappe, un demi-bloc, ou sur un mob dont l'œil est bas (araignée, slime, bébé, poisson, ver d'argent) est refusé alors que la boîte est visible. 1 point par coup, 5 coups = alerte, 10 = annulation des coups en ENFORCE. Le test existant ne couvre que le calcul des points. +- **Preuve** : non testable sans le jeu (lancer de rayon, boîtes de collision). Essai en jeu n° 5. +- **Correction** : tester la visibilité vers **3 points** de la boîte (œil, centre, pieds) et déclarer invisible seulement si les trois sont bloqués ; poids 0,5. +- **Risque** : faible. + +## F19 : contraption plus grande que 3 blocs : exemption manquée +- **Contrôle** : exemptions `pocheContraption` (Garde.java:242-255). **Gravité** : élevée. **Type** : faux positif **[À VÉRIFIER]**. +- **Description** : la détection cherche une entité dont le nom de classe commence par un préfixe, dans `boundingBox.inflate(3)` du joueur. La boîte d'une entité de contraption n'est pas celle de sa structure (probable : petite, au point d'ancrage). Un joueur à l'autre bout d'un train ou d'un dirigeable est à plus de 3 blocs : non exempté, et porté à plusieurs blocs/tick. +- **Preuve** : non testable (dépend de Create). Essai n° 6. +- **Correction** : tester si le joueur est **sur** la contraption (passager, ou collision avec la structure via l'API Create `ContraptionCollider`), ou augmenter `distanceContraptionBlocs` (max 16) ; ajouter un mode « exempté tant que la contraption bouge (vitesse de l'entité > 0) ». +- **Risque** : moyen (une exemption large est exploitable : un tricheur reste près d'une contraption, voir F25). + +## F20 : les véhicules ne sont jamais contrôlés +- **Contrôle** : mixins (seul `handleMovePlayer` est accroché). **Gravité** : élevée. **Type** : trou de couverture. +- **Description** : `handleMoveVehicle` (ServerGamePacketListenerImpl:389) n'est pas accroché. Boat fly, vitesse de cheval, minecart, boat jesus : seuls 10 blocs/paquet vanilla (:410, seuil fixe 100 sans `i`). La famille `enVehicule` exempte aussi `handleMovePlayer`. Un joueur dans un bateau est un tricheur libre. +- **Preuve** : lecture du code (mixin et vanilla). +- **Correction** : mixin `handleMoveVehicle` (mêmes `vitesse` et `vol`, bornes par type d'entité : bateau 0,4 sur l'eau, cheval 0,45 ; vol : bateau hors de l'eau sans bloc = infraction). +- **Risque** : moyen (Create, Aeronautics et montures modifiées). + +## F21 : état par joueur recréé après la déconnexion, concurrence +- **Contrôle** : `Garde.MARQUES`, `Moteur.suivis`. **Gravité** : moyenne. **Type** : bug (fuite, concurrence). +- **Description** : en plus de F01, un paquet de mouvement déjà en file après `PlayerLoggedOutEvent` rappelle `marques(uuid)`/`suivi(uuid)` (`computeIfAbsent`) : l'entrée du joueur parti est recréée et ne sera plus jamais libérée (une par déconnexion). Petit, mais cumulatif sur un serveur qui reste des semaines. `Garde.arreter()` ne vide pas `ALERTES_COUPEES`. Les `Suivi` de `/garde status ` hors ligne ne sont pas créés (joueur en ligne uniquement : ok). +- **Preuve** : lecture du code. `joueurParti` (Garde.java:142-146) retire, mais rien n'empêche la recréation. +- **Correction** : ne pas créer d'entrée si le joueur n'est plus dans `PlayerList` ; purge périodique des UUID hors ligne ; vider `ALERTES_COUPEES` à l'arrêt. +- **Risque** : faible. + +## F22 : `no-fall` : la chute se réinitialise sur une montée vanilla +- **Contrôle** : `no-fall`. **Gravité** : moyenne. **Type** : contournement **[À VÉRIFIER]**. +- **Description** : vanilla fait `if (flag4) this.player.resetFallDistance()` quand le paquet monte de la dernière position valide (ServerGamePacketListenerImpl:960-961). Un client qui intercale un paquet qui monte de 0,01 bloc juste avant l'impact remet la distance de chute à 0 sans passer par `onGround`. `no-fall` (core/NoFall.java) ne regarde que `onGround` client contre serveur, et ne corrige qu'en ENFORCE (désactivé). +- **Preuve** : non testable sans le jeu. Essai n° 7. +- **Correction** : contrôler `dy` positif en chute libre (la vitesse verticale serveur précédente est < -0,5 puis un paquet monte) = infraction + conserver la distance de chute côté mod. +- **Risque** : moyen. + +## F23 : configuration modifiée depuis un autre thread +- **Contrôle** : `GardeConfig`, `GardeSpec.onConfig`. **Gravité** : faible. **Type** : bug (concurrence). +- **Description** : `ModConfigEvent` est déclenché par l'observateur de fichiers ; `appliquer` modifie les champs publics non volatils lus par le thread serveur. Course bénigne (pas de verrou), mais des lectures obsolètes ou un `seuilSetback < seuilAlerte` transitoire sont possibles pendant la recopie. +- **Preuve** : lecture du code. +- **Correction** : construire une `GardeConfig` neuve et l'échanger d'un coup (référence `volatile`). +- **Risque** : nul. + +## F24 : mixins fragiles +- **Contrôle** : `RiptideMoveMixin`, `MovePacketMixin`. **Gravité** : moyenne. **Type** : fragilité. +- **Description** : + - `@ModifyConstant(100.0F)` et `300.0F` visent des constantes de `handleMovePlayer` : un autre mod (Lithium, ServerCore, Aeronautics) ou une mise à jour de NeoForge qui touche cette méthode peut empêcher l'application ou doubler l'injection. `defaultRequire=1` fait **planter le démarrage** du serveur si une injection est absente. + - GastinelClaims 1.1.6 contient le **même** mixin ; les deux relèvent le seuil (le README dit « sans danger », mais deux `@ModifyConstant` sur la même constante : le deuxième reçoit la valeur déjà modifiée, d'où seuil max : ok) ; le `getMaximumFlyingTicks` est injecté deux fois. + - `@ModifyArg ... doCheckFallDamage(DDDZ)V` correspond à **deux** appels (succès et rejet), et le second reçoit aussi le drapeau corrigé. + - `required: true` sans repli : un échec d'injection empêche le serveur de démarrer. +- **Preuve** : lecture. `MixinsAppliquesTest` ne charge que la classe vanilla (pas les autres mods). +- **Correction** : retirer le mixin de GastinelClaims (tâche 79) avant le déploiement ; utiliser `require = 0` pour le riptide et journaliser l'échec ; test d'intégration avec les vrais mods (Lithium, ServerCore). +- **Risque** : faible. + +## F25 : Aeronautics (Sable) : comportement du joueur inconnu +- **Contrôle** : exemptions contraption. **Gravité** : élevée. **Type** : faux positif **[À VÉRIFIER]**. +- **Description** : Aeronautics s'appuie sur Sable (« sub-levels ») selon https://modrinth.com/mod/aeroclaims. On ne sait pas si le joueur est passager, déplacé par la physique, ou téléporté dans un plan séparé. Les préfixes par défaut `dev.simulated_team,dev.ryanhcode` sont **des suppositions**. Si le joueur se trouve dans un plan avec des coordonnées décalées, la proximité d'une entité ne le reconnaît pas. Inversement, l'exemption par proximité est un **blanc-seing** : n'importe quel tricheur à 3 blocs d'une entité Create est exempté de tout (combat compris, `Famille.COMBAT` aussi). +- **Preuve** : non testable. Essais n° 6 et 8. +- **Correction** : relever les noms de classe en jeu (`/garde` : ajouter une commande de diagnostic qui liste les entités à 5 blocs), et limiter l'exemption aux joueurs réellement **passagers/sur la structure**, jamais au combat sans condition. +- **Risque** : moyen. + +--- + +## Ce qui est bon (pour ne pas casser) +- Cœur pur testable, 98 tests, pas d'allocation par paquet. +- OBSERVE par défaut, jamais de bannissement. +- Plafond de VL et paliers cohérents (`Paliers.java`), `seuilSetback`/`seuilExpulsion` ramenés au minimum (GardeSpec.java:135-136). +- Dimension vérifiée avant le setback (Garde.java:422). +- Journal limité à 1 ligne/s/contrôle, alertes à 5 s. diff --git a/audit/AVANCEMENT.md b/audit/AVANCEMENT.md new file mode 100644 index 0000000..0ffbed3 --- /dev/null +++ b/audit/AVANCEMENT.md @@ -0,0 +1,16 @@ +# Avancement de l'audit (mis à jour à chaque étape) + +Démarré : 2026-10-14. + +## État +- [x] Lecture README + PLAN + tout le code (core, adaptateurs, mixins, config) + source vanilla 1.21.1 (jar sources NeoForge de build/moddev/artifacts). +- [x] ÉTAPE 1 faite (01-inventaire-triches.md) +- [x] ÉTAPE 2 faite (02-failles-detection.md, tests-proposes/AuditFaillesTest.java 17/17) +- [x] ÉTAPE 3 faite (00-SYNTHESE.md). AUDIT TERMINÉ. + +## Notes de reprise (ne pas refaire) +- Source vanilla extraite dans le scratchpad de la session ; si perdue : `unzip build/moddev/artifacts/neoforge-21.1.234-sources.jar net/minecraft/server/network/ServerGamePacketListenerImpl.java`. +- Constats déjà établis (à écrire en étape 2) : F-thread (HEAD du mixin tourne aussi sur le thread réseau -> timer compté x2), + riptide tenu = exemption totale + seuil vanilla 100 blocs/paquet, grâce téléportation déclenchée par tout teleport() vanilla, + ping falsifiable = tolérance x1,5, vol aveugle si ticks != 1, fenêtres Fenetre(128/512/32) saturables, véhicules jamais contrôlés, + hasLineOfSight yeux-à-yeux (faux positifs), killaura-angle contourné par rotation silencieuse. diff --git a/audit/tests-proposes/AuditFaillesTest.java b/audit/tests-proposes/AuditFaillesTest.java new file mode 100644 index 0000000..2bf4109 --- /dev/null +++ b/audit/tests-proposes/AuditFaillesTest.java @@ -0,0 +1,321 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.time.LocalDate; +import java.time.ZoneOffset; +import java.util.List; +import java.util.UUID; +import org.junit.jupiter.api.Test; + +/** + * Preuves de l'audit 2026-10-14. NE PAS copier dans src/test : à lancer dans une copie jetable. + * Chaque test porte l'identifiant de la faille (voir audit/02-failles-detection.md). + * Convention : un test « BYPASS » ou « FAUX_POSITIF » est vert tant que la faille existe ; il passera au rouge + * quand la correction sera appliquée (alors, inverser l'assertion). + */ +class AuditFaillesTest { + + private final GardeConfig cfg = new GardeConfig(); + private final Moteur moteur = new Moteur(cfg); + private final UUID j = UUID.randomUUID(); + + private static EtatMouvement mv(double dxz, double dy, int ticks, boolean solServeur, boolean sprint) { + return new EtatMouvement(dxz, dy, ticks, solServeur, solServeur, sprint, false, false, 0, 0, false, false); + } + + private static boolean contient(List v, Controle c) { + return v.stream().anyMatch(x -> x.controle() == c); + } + + // ---------------------------------------------------------------- F01 + /** Le HEAD du mixin tourne aussi sur le thread réseau : chaque paquet est compté deux fois. */ + @Test + void F01_timer_paquet_compte_deux_fois_faux_positif() { + boolean simple = false; + UUID a = UUID.randomUUID(); + for (long t = 0; t < 10_000; t += 50) { + if (contient(moteur.paquetMouvement(a, t, EtatJoueur.normal()), Controle.TIMER)) simple = true; + } + assertFalse(simple, "20 paquets/s comptés une fois : aucune infraction"); + + boolean double_ = false; + UUID b = UUID.randomUUID(); + for (long t = 0; t < 10_000; t += 50) { + moteur.paquetMouvement(b, t, EtatJoueur.normal()); // thread réseau + if (contient(moteur.paquetMouvement(b, t + 1, EtatJoueur.normal()), Controle.TIMER)) double_ = true; // thread serveur + } + assertTrue(double_, "20 paquets/s comptés deux fois = 40/s : infraction pour un joueur honnête"); + } + + // ---------------------------------------------------------------- F02 + /** Au-delà de ~512 paquets/s la fenêtre circulaire ne couvre plus 2 s : le timer ne voit plus rien. */ + @Test + void F02_timer_inondation_BYPASS() { + UUID flood = UUID.randomUUID(); + boolean vu = false; + for (long t = 0; t < 8000; t++) { // 1 paquet par ms = 1000/s + if (contient(moteur.paquetMouvement(flood, t, EtatJoueur.normal()), Controle.TIMER)) vu = true; + } + assertFalse(vu, "1000 paquets/s ne lèvent AUCUNE infraction (fenêtre de 512)"); + + UUID modere = UUID.randomUUID(); + boolean vuModere = false; + for (long t = 0; t < 8000; t += 10) { // 100 paquets/s + if (contient(moteur.paquetMouvement(modere, t, EtatJoueur.normal()), Controle.TIMER)) vuModere = true; + } + assertTrue(vuModere, "100 paquets/s sont bien vus (témoin)"); + } + + // ---------------------------------------------------------------- F03 + /** Timer 1,1x (22 paquets/s) et rafales de type blink : invisibles. */ + @Test + void F03_timer_faible_et_blink_BYPASS() { + UUID a = UUID.randomUUID(); + boolean vu = false; + for (long t = 0; t < 60_000; t += 1000.0 / 22) { + if (contient(moteur.paquetMouvement(a, t, EtatJoueur.normal()), Controle.TIMER)) vu = true; + } + assertFalse(vu, "22 paquets/s soutenus pendant 60 s : jamais vu (+10 % de vitesse permanent)"); + + UUID b = UUID.randomUUID(); + boolean vuBlink = false; + for (long t = 0; t < 5000; t += 50) moteur.paquetMouvement(b, t, EtatJoueur.normal()); // 20/s normal + // 5 s retenues puis libérées : 100 paquets en 1 s + for (int i = 0; i < 100; i++) { + if (contient(moteur.paquetMouvement(b, 10_000 + i * 10L, EtatJoueur.normal()), Controle.TIMER)) vuBlink = true; + } + assertFalse(vuBlink, "une rafale de 100 paquets après 5 s de silence passe (pas de balance cumulée)"); + } + + // ---------------------------------------------------------------- F04 + /** Tenir un trident Impulsion relève le seuil vanilla de 100 à 10000 (carré) : 99 blocs par paquet passent. */ + @Test + void F04_riptide_tenu_seuil_vanilla_neutralise_BYPASS() { + float vanilla = RiptideTolerance.seuil(100f, false, -1); + float tenu = RiptideTolerance.seuil(100f, true, -1); // le mixin passe riptide=true si le trident est en main + assertEquals(100f, vanilla); + assertEquals(10_000f, tenu); + double distance = 99.0; // un « TP » de 99 blocs en un paquet + assertTrue(distance * distance > vanilla, "refusé par vanilla (moved too quickly)"); + assertFalse(distance * distance > tenu, "accepté dès qu'un trident Impulsion est en main"); + } + + // ---------------------------------------------------------------- F05 + /** Tout teleport() vanilla (dont le setback du mod et un « moved too quickly » provoqué) ouvre 2 s d'exemption. */ + @Test + void F05_grace_teleportation_rechargee_en_boucle_BYPASS() { + long now = 0; + boolean vu = false; + // vitesse folle de 1,0 bloc/tick ; un faux paquet « trop rapide » toutes les 30 ticks rechargerait la grâce + for (int tick = 0; tick < 600; tick++) { + int depuisTp = tick % 30; + EtatJoueur etat = EtatJoueur.builder().ticksDepuisTeleport(depuisTp).build(); + if (!moteur.mouvement(j, now, etat, mv(1.0, 0, 1, true, true)).isEmpty()) vu = true; + now += 50; + } + assertFalse(vu, "30 s à 20 blocs/s : aucune infraction tant que la grâce est rechargée"); + + UUID t = UUID.randomUUID(); + boolean vuSansTp = false; + now = 0; + for (int tick = 0; tick < 600; tick++) { + if (!moteur.mouvement(t, now, EtatJoueur.normal(), mv(1.0, 0, 1, true, true)).isEmpty()) vuSansTp = true; + now += 50; + } + assertTrue(vuSansTp, "témoin : sans grâce, la vitesse est vue"); + } + + // ---------------------------------------------------------------- F06 + /** Tout dégât (feu, cactus, wither…) exempte le mouvement 20 ticks : se blesser toutes les secondes suffit. */ + @Test + void F06_grace_degats_BYPASS() { + long now = 0; + boolean vu = false; + for (int tick = 0; tick < 600; tick++) { + EtatJoueur etat = EtatJoueur.builder().ticksDepuisRecul(tick % 20).build(); + if (!moteur.mouvement(j, now, etat, mv(0.9, 0, 1, true, true)).isEmpty()) vu = true; + now += 50; + } + assertFalse(vu, "un dégât par seconde (<= 20 ticks, borne incluse) : exemption permanente"); + } + + // ---------------------------------------------------------------- F07 + /** Un ping falsifié (PingSpoof) à plus de 250 ms multiplie tous les seuils par 1,5. */ + @Test + void F07_ping_spoof_elargit_les_seuils_BYPASS() { + UUID honnete = UUID.randomUUID(); + UUID spoof = UUID.randomUUID(); + boolean vuNormal = false, vuSpoof = false; + long now = 0; + for (int tick = 0; tick < 200; tick++) { + EtatMouvement m = mv(0.40, 0, 1, true, true); // 0,40 bloc/tick au sol en sprint (vanilla : ~0,28) + if (!moteur.mouvement(honnete, now, EtatJoueur.builder().pingMs(30).build(), m).isEmpty()) vuNormal = true; + if (!moteur.mouvement(spoof, now, EtatJoueur.builder().pingMs(300).build(), m).isEmpty()) vuSpoof = true; + now += 50; + } + assertTrue(vuNormal, "ping 30 ms : vu"); + assertFalse(vuSpoof, "ping 300 ms : la même vitesse n'est plus vue"); + } + + // ---------------------------------------------------------------- F08 + /** Le contrôle de vol ne s'évalue que si exactement 1 tick sépare deux paquets. */ + @Test + void F08_vol_aveugle_si_ticks_different_de_1_BYPASS() { + boolean vu1 = false, vu2 = false; + UUID a = UUID.randomUUID(); + UUID b = UUID.randomUUID(); + long now = 0; + for (int tick = 0; tick < 60; tick++) { + EtatMouvement hover1 = mv(0, 0, 1, false, false); + EtatMouvement hover2 = mv(0, 0, 2, false, false); + if (contient(moteur.mouvement(a, now, EtatJoueur.normal(), hover1), Controle.VOL)) vu1 = true; + if (contient(moteur.mouvement(b, now, EtatJoueur.normal(), hover2), Controle.VOL)) vu2 = true; + now += 50; + } + assertTrue(vu1, "hover à 1 paquet par tick : vu"); + assertFalse(vu2, "hover avec un paquet tous les 2 ticks : jamais vu"); + } + + // ---------------------------------------------------------------- F09 + /** Rester sous le tampon : +33 % au sol et +18 % en l'air, soutenus. */ + @Test + void F09_vitesse_sous_le_tampon_BYPASS() { + UUID sol = UUID.randomUUID(); + UUID air = UUID.randomUUID(); + boolean vuSol = false, vuAir = false; + long now = 0; + for (int tick = 0; tick < 1200; tick++) { + if (contient(moteur.mouvement(sol, now, EtatJoueur.normal(), mv(0.37, 0, 1, true, true)), Controle.VITESSE)) vuSol = true; + if (contient(moteur.mouvement(air, now, EtatJoueur.normal(), mv(0.49, 0, 1, false, true)), Controle.VITESSE)) vuAir = true; + now += 50; + } + // vanilla : sprint au sol ~0,28 bloc/tick (5,6 b/s), saut en courant ~0,36 + assertFalse(vuSol, "0,37 bloc/tick au sol (7,4 b/s, +32 %) soutenu 60 s : jamais vu"); + assertFalse(vuAir, "0,49 bloc/tick en l'air (9,8 b/s) soutenu 60 s : jamais vu"); + } + + // ---------------------------------------------------------------- F10 + /** Glace, âmes, eau, slime : le tick est ignoré, quelle que soit la vitesse. */ + @Test + void F10_milieux_exemptes_totalement_BYPASS() { + boolean vu = false; + long now = 0; + for (int tick = 0; tick < 200; tick++) { + EtatMouvement glace = new EtatMouvement(3.0, 0, 1, true, true, true, false, false, 0, 0, false, true); + EtatMouvement eau = new EtatMouvement(3.0, 0, 1, false, false, true, false, false, 0, 0, true, false); + if (!moteur.mouvement(j, now, EtatJoueur.normal(), glace).isEmpty()) vu = true; + if (!moteur.mouvement(j, now, EtatJoueur.normal(), eau).isEmpty()) vu = true; + now += 50; + } + assertFalse(vu, "3 blocs/tick sur glace ou dans l'eau : aucune infraction (60 blocs/s)"); + } + + // ---------------------------------------------------------------- F11 + /** Killaura à rotation silencieuse : l'excédent d'angle est 0 ; 3 cibles par seconde : toléré. */ + @Test + void F11_killaura_rotation_silencieuse_BYPASS() { + boolean vu = false; + long now = 0; + for (int i = 0; i < 100; i++) { + int cible = 100 + (i % 3); // 3 cibles qui tournent + vu |= !moteur.attaque(j, now, EtatJoueur.normal(), 0.0, cible, true).isEmpty(); + now += 330; // ~3 coups par seconde + } + assertFalse(vu, "regard parfait + 3 cibles/s : jamais vu"); + } + + // ---------------------------------------------------------------- F12 + /** Au-delà de 128 coups/s la fenêtre ne contient plus « la seconde précédente » : cadence muette. */ + @Test + void F12_cadence_saturation_BYPASS() { + UUID spam = UUID.randomUUID(); + UUID rapide = UUID.randomUUID(); + boolean vuSpam = false, vuRapide = false; + for (int tick = 0; tick < 100; tick++) { + for (int k = 0; k < 10; k++) { // 10 coups par tick = 200/s + if (contient(moteur.attaque(spam, tick * 50L, EtatJoueur.normal(), 0, 7, true), Controle.CADENCE)) vuSpam = true; + } + for (int k = 0; k < 2; k++) { // 2 coups par tick = 40/s + if (contient(moteur.attaque(rapide, tick * 50L, EtatJoueur.normal(), 0, 7, true), Controle.CADENCE)) vuRapide = true; + } + } + assertTrue(vuRapide, "40 coups/s : vu (témoin)"); + assertFalse(vuSpam, "200 coups/s : jamais vu (fenêtre de 128)"); + } + + // ---------------------------------------------------------------- F13 + /** 5 cibles par seconde passent si 8 coups par tick sur une 6e entité chassent les autres de la fenêtre (32). */ + @Test + void F13_cibles_multiples_fenetre_saturable_BYPASS() { + boolean vu = false; + for (int tick = 0; tick < 200; tick++) { + long now = tick * 50L; + for (int k = 0; k < 8; k++) vu |= contient(moteur.attaque(j, now, EtatJoueur.normal(), 0, 1, true), Controle.KILLAURA_CIBLES); + if (tick % 5 == 0) { + int autre = 10 + (tick / 5) % 4; + vu |= contient(moteur.attaque(j, now, EtatJoueur.normal(), 0, autre, true), Controle.KILLAURA_CIBLES); + } + } + assertFalse(vu, "5 entités touchées par seconde : jamais vu (fenêtre de 32 entrées)"); + } + + // ---------------------------------------------------------------- F14 + /** Atterrissage après élytres rapides : aucune grâce, le surplus de vitesse dépasse le tampon. */ + @Test + void F14_atterrissage_elytres_faux_positif() { + boolean vu = false; + long now = 0; + double v = 1.7; // blocs/tick, plané avec fusée + for (int tick = 0; tick < 12; tick++) { + // au sol, friction 0,6 × 0,91 = 0,546 par tick, joueur plus en élytres (isFallFlying=false) + if (!moteur.mouvement(j, now, EtatJoueur.normal(), mv(v, 0, 1, true, true)).isEmpty()) vu = true; + v *= 0.546; + now += 50; + } + assertTrue(vu, "un atterrissage à 1,7 bloc/tick lève une infraction vitesse : faux positif"); + } + + // ---------------------------------------------------------------- F15 + /** Le fichier du jour n'est jamais purgé : le plafond de taille ne s'applique pas pendant la journée. */ + @Test + void F15_traces_plafond_non_applique_dans_la_journee() throws Exception { + Path dossier = Files.createTempDirectory("garde-traces"); + try (TraceFichier t = new TraceFichier(dossier, 7, 1024)) { + long epoch = LocalDate.of(2026, 10, 14).atStartOfDay().toInstant(ZoneOffset.UTC).toEpochMilli(); + String ligne = "x".repeat(1000); + for (int i = 0; i < 2000; i++) t.ecrire(epoch + i, ligne); + t.flush(); + long taille = Files.size(t.fichierDuJour(LocalDate.of(2026, 10, 14))); + assertTrue(taille > 1_000_000, "plafond de 1 Ko demandé, fichier de " + taille + " octets"); + } + } + + // ---------------------------------------------------------------- F16 + /** La décroissance est figée à la création du suivi : /garde reload ne change rien pour les joueurs connectés. */ + @Test + void F16_decroissance_figee_a_la_creation() { + Suivi s = moteur.suivi(j); + cfg.vlDecroissanceParSeconde = 0.0; // l'op « gèle » les VL dans la config + s.vl.ajouter(Controle.VITESSE, 10, 0); + assertEquals(5.0, s.vl.valeur(Controle.VITESSE, 10_000), 1e-9, "décroît encore de 0,5/s malgré la config à 0"); + } + + // ---------------------------------------------------------------- F17 + /** Le tampon 20 ticks est un total : en alternant 19 ticks légaux et 1 tick « téléporté », jamais d'infraction. */ + @Test + void F17_tampon_vitesse_rafale_isolee_BYPASS() { + boolean vu = false; + long now = 0; + for (int tick = 0; tick < 400; tick++) { + double d = (tick % 20 == 0) ? 1.7 : 0.28; // un « bond » de 1,7 bloc toutes les secondes + vu |= !moteur.mouvement(j, now, EtatJoueur.normal(), mv(d, 0, 1, true, true)).isEmpty(); + now += 50; + } + assertFalse(vu, "1,4 bloc d'excès par seconde (+25 blocs/min) : sous le tampon de 1,5 bloc"); + } +}