From bbb08a95f83c50e69bb78e56ea8711c1c2b8b97e Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Fri, 16 Oct 2026 01:07:49 +0200 Subject: [PATCH] GastinelGarde autotests : contournements de la revue de securite, C13, C15 Les 4 contournements de la revue des commits 7a5a1c9 / 937d43d sont prouves : ping > 500 ms exempte, regard et oeil suivants sans borne, table SUIVIES pleine sans eviction, fenetre d'historique elargie par le ping declare. C13 (minimum avec le paquet suivant, reach 3,3 et 4,0 sur cible mobile) et C15 (bhop 0,40, speed sol 0,37, timer 1,09) prouves. Code de production inchange. 228 tests, 0 echec (cornafserver, conteneur eclipse-temurin:21-jdk). Co-Authored-By: Claude Opus 5.5 --- .../gastinelgarde/AutotestSuiviesTest.java | 64 +++++ .../core/AutotestContournementsTest.java | 259 ++++++++++++++++++ 2 files changed, 323 insertions(+) create mode 100644 src/test/java/com/gastinelgarde/AutotestSuiviesTest.java create mode 100644 src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java diff --git a/src/test/java/com/gastinelgarde/AutotestSuiviesTest.java b/src/test/java/com/gastinelgarde/AutotestSuiviesTest.java new file mode 100644 index 0000000..9f7980c --- /dev/null +++ b/src/test/java/com/gastinelgarde/AutotestSuiviesTest.java @@ -0,0 +1,64 @@ +package com.gastinelgarde; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.lang.reflect.Field; +import java.util.Map; +import net.minecraft.world.entity.Entity; +import net.minecraft.world.entity.EntityType; +import net.minecraft.world.entity.Marker; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.Test; + +/** + * Autotests du 16/10/2026, nuit : contournement n°3 de la revue de sécurité (table SUIVIES pleine). + * + * Garde.boitesVues n'ajoute une cible non joueur à la table que si elle compte moins de SUIVIES_MAX entrées ; sinon + * elle renvoie null (pas de mesure) et ne la suivra jamais tant que la table reste pleine. La table est commune à + * tout le serveur, les joueurs connectés y comptent aussi (sans plafond), une entrée vit 10 s après le dernier coup. + * + * Le test remplit la table par réflexion avec des identifiants négatifs (jamais attribués) et frappe une entité + * « marker » construite sans monde. Si l'environnement de test ne permet pas de construire l'entité, le test est + * ignoré (assumption) au lieu d'échouer. + */ +class AutotestSuiviesTest { + + @SuppressWarnings("unchecked") + @Test + void FAILLE_revue3_tablePleineLesNouvellesCiblesNeSontJamaisSuivies() throws Exception { + Field fTable = Garde.class.getDeclaredField("SUIVIES"); + fTable.setAccessible(true); + Map table = (Map) fTable.get(null); + Field fMax = Garde.class.getDeclaredField("SUIVIES_MAX"); + fMax.setAccessible(true); + int max = fMax.getInt(null); + assertEquals(256, max); + + Entity cible; + try { + cible = new Marker(EntityType.MARKER, null); + } catch (Throwable t) { + Assumptions.abort("entité impossible à construire hors jeu : " + t); + return; + } + table.clear(); + try { + // Témoin : table vide, la cible frappée entre dans la table (mesurée au coup suivant). + assertNull(Garde.boitesVues(cible, null, 1000), "premier coup : historique incomplet"); + assertTrue(table.containsKey(cible.getId()), "témoin : la cible est suivie"); + + table.clear(); + for (int i = 0; i < max; i++) table.put(-1 - i, null); + for (int k = 0; k < 5; k++) { + assertNull(Garde.boitesVues(cible, null, 1000 + 20 * k), "coup " + k + " non mesuré"); + } + assertFalse(table.containsKey(cible.getId()), "prouvé : table pleine, la cible n'est jamais suivie"); + assertEquals(max, table.size(), "aucune éviction"); + } finally { + table.clear(); + } + } +} diff --git a/src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java b/src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java new file mode 100644 index 0000000..333618d --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java @@ -0,0 +1,259 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** + * Autotests du 16/10/2026, nuit : contournements signalés par la revue de sécurité automatique des commits 7a5a1c9 / + * 937d43d (contrôle coups-hors-boite) et constats C13, C15 de l'autocritique. + * + * Un test {@code FAILLE_…} passe tant que le contournement marche ; il échouera quand il sera corrigé (inverser + * alors l'assertion). Chaque faille a un test « témoin » qui montre que, sans le contournement, la triche est vue. + * Le contournement n°3 (table SUIVIES pleine) dépend de Minecraft : voir {@code com.gastinelgarde.AutotestSuiviesTest}. + */ +class AutotestContournementsTest { + + private static final double V = 0.28; // cible qui sprinte, blocs/tick + private GardeConfig cfg; + private Moteur moteur; + private final UUID joueur = UUID.randomUUID(); + + @BeforeEach + void init() { + cfg = new GardeConfig(); + moteur = new Moteur(cfg); + } + + private static double[] boite(double x) { + return new double[] {x - 0.3, 0, -0.3, x + 0.3, 1.8, 0.3}; + } + + /** Boîtes vues : cible qui avance de V par tick en x, arrivée en xNow (comme Garde92Test). */ + private static double[][] vues(double xNow, int fenetre) { + double[][] b = new double[fenetre + 2][]; + for (int i = 0; i < b.length; i++) b[i] = boite(xNow - V * (b.length - 1 - i)); + return b; + } + + private static double[] vers(double[] de, double x, double y, double z) { + return new double[] {x - de[0], y - de[1], z - de[2]}; + } + + private static double points(List vs, Controle c) { + double p = 0; + for (Verdict v : vs) if (v.controle() == c) p += v.points(); + return p; + } + + /** Coup mesuré par coups-hors-boite, puis paquet de mouvement suivant (œil et regard « suivants »). */ + private List coup(long t, EtatJoueur etat, double[] oeil, double[] regard, double[] oeilSuivant, + double[] regardSuivant, double xCible, double[][] vues) { + List vs = new ArrayList<>(moteur.coupDiffere(joueur, t, etat, oeil, regard, boite(xCible), 3.0, + V, true, false, oeil, vues)); + vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeilSuivant, regardSuivant)); + return vs; + } + + // --- Revue n°1 : ping gonflé au-delà de seriePingMaxMs = coup exempté ----------------------------------------- + + private double serieHitboxAvecPing(int ping) { + moteur = new Moteur(cfg); + EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build(); + int fenetre = PorteeHitbox.ticksFenetre(ping, cfg); + double total = 0; + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] oeil = {x, 1.62, -3.0}; + double[] regard = vers(oeil, x + 0.75, 1.2, 0); // client « hitbox » : 0,45 bloc devant la cible + total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)), + Controle.COUPS_HORS_BOITE); + } + return total; + } + + @Test + void FAILLE_revue1_pingDeclareAuDessusDe500msExempteTotalementLesCoups() { + assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs) > 0, "témoin : à 500 ms, la série est vue"); + assertEquals(0, serieHitboxAvecPing(cfg.seriePingMaxMs + 1), 1e-9, + "prouvé : à 501 ms (ping falsifiable, F07), aucun coup n'est mesuré"); + } + + // --- Revue n°2 / C13 : regard et œil du paquet SUIVANT acceptés sans borne -------------------------------------- + + @Test + void FAILLE_revue2_regardSuivantRameneSurLaCibleEffaceLeCoupHorsBoite() { + int fenetre = PorteeHitbox.ticksFenetre(30, cfg); + double temoin = 0, triche = 0; + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] oeil = {x, 1.62, -3.0}; + double[] hors = {0, 0, -1}; // regard tourné à 180° de la cible au moment du coup + double[] surCible = vers(oeil, x, 1.2, 0); + triche += points(coup(k * 600L, EtatJoueur.normal(), oeil, hors, oeil, surCible, x, vues(x, fenetre)), + Controle.COUPS_HORS_BOITE); + } + moteur = new Moteur(cfg); + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] oeil = {x, 1.62, -3.0}; + double[] hors = {0, 0, -1}; + temoin += points(coup(k * 600L, EtatJoueur.normal(), oeil, hors, oeil, hors, x, vues(x, fenetre)), + Controle.COUPS_HORS_BOITE); + } + assertTrue(temoin > 0, "témoin : le même regard gardé au paquet suivant est vu"); + assertEquals(0, triche, 1e-9, "prouvé : un demi-tour du regard au paquet suivant efface tout (aucune borne d'angle)"); + } + + @Test + void FAILLE_revue2_oeilSuivantAvanceDe09BlocEffaceLaPorteeAllongee() { + int fenetre = PorteeHitbox.ticksFenetre(30, cfg); + double temoin = 0, triche = 0; + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] loin = {x, 1.62, -3.9}; // 3,6 blocs de la boîte : reach + double[] proche = {x, 1.62, -3.0}; // 0,9 bloc plus près au paquet suivant (sprint : 0,28 bloc/tick) + double[] regard = vers(loin, x, 1.2, 0); + triche += points(coup(k * 600L, EtatJoueur.normal(), loin, regard, proche, vers(proche, x, 1.2, 0), x, + vues(x, fenetre)), Controle.COUPS_HORS_BOITE); + } + moteur = new Moteur(cfg); + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] loin = {x, 1.62, -3.9}; + double[] regard = vers(loin, x, 1.2, 0); + temoin += points(coup(k * 600L, EtatJoueur.normal(), loin, regard, loin, regard, x, vues(x, fenetre)), + Controle.COUPS_HORS_BOITE); + } + assertTrue(temoin > 0); + assertEquals(0, triche, 1e-9, "prouvé : l'œil suivant n'est pas borné à un déplacement légal"); + } + + @Test + void FAILLE_C13_porteeEtHitboxGardentLeMinimumAvecLePaquetSuivant() { + cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF); + double[] b = boite(0); + double[] loin = {0, 1.62, -4.3}; // 4,0 blocs de la boîte : refus vanilla à la limite + double[] proche = {0, 1.62, -3.5}; // 3,2 blocs au paquet suivant + double[] regard = vers(loin, 0, 1.0, 0); + // Témoin : paquet suivant identique. + List t = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0, + true, false)); + t.addAll(moteur.regardPorteeHitbox(joueur, 50, loin, regard)); + assertTrue(points(t, Controle.PORTEE) > 0, "témoin : 4,0 blocs sur cible immobile est vu"); + + moteur = new Moteur(cfg); + List v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0, + true, false)); + v.addAll(moteur.regardPorteeHitbox(joueur, 50, proche, vers(proche, 0, 1.0, 0))); + assertEquals(0, points(v, Controle.PORTEE), 1e-9, "prouvé : s'avancer au paquet suivant efface la portée"); + + // Angle killaura : regard à 180° au coup, sur la cible au paquet suivant. + cfg.mode(Controle.PORTEE, Mode.OFF); + cfg.mode(Controle.HITBOX, Mode.OFF); + moteur = new Moteur(cfg); + double[] oeil = {0, 1.62, -2.5}; + List a = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil, new double[] {0, 0, -1}, + b, 3.0, 0, false, true)); + a.addAll(moteur.regardPorteeHitbox(joueur, 50, oeil, vers(oeil, 0, 1.0, 0))); + assertEquals(0, points(a, Controle.KILLAURA_ANGLE), 1e-9, "prouvé : rotation silencieuse effacée"); + } + + @Test + void FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee() { + cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF); + double[] b = boite(0); + double[] oeil33 = {0, 1.62, -3.59}; // 3,29 blocs + List v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil33, + vers(oeil33, 0, 1.0, 0), b, 3.0, 0, true, false)); + v.addAll(moteur.terminerCoup(joueur)); + assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,29 blocs sur cible immobile : rien"); + + moteur = new Moteur(cfg); + double[] oeil40 = {0, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte + v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil40, vers(oeil40, 0, 1.0, 0), b, 3.0, + V, true, false)); + v.addAll(moteur.terminerCoup(joueur)); + assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,99 blocs sur cible qui sprinte : rien pour portee"); + } + + // --- Revue n°4 : la fenêtre d'historique grandit avec le ping déclaré ------------------------------------------ + + private double serieDerriereLaCible(int ping) { + moteur = new Moteur(cfg); + EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build(); + int fenetre = PorteeHitbox.ticksFenetre(ping, cfg); // ce que Garde.boitesVues calcule depuis latency() + double total = 0; + for (int k = 0; k < 10; k++) { + double x = 10 * k; + double[] oeil = {x - 1.5, 1.62, -2.5}; + // Client « hitbox » : touche 3,3 blocs DERRIÈRE le centre de la cible (là où elle était il y a ~12 ticks). + double[] regard = vers(oeil, x - 3.6, 1.2, 0); + total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)), + Controle.COUPS_HORS_BOITE); + } + return total; + } + + @Test + void FAILLE_revue4_pingDeclareA450msElargitLaFenetreEtCacheLaTriche() { + assertEquals(8, PorteeHitbox.ticksFenetre(30, cfg)); + assertEquals(16, PorteeHitbox.ticksFenetre(450, cfg)); + assertEquals(17, PorteeHitbox.ticksFenetre(500, cfg)); + assertTrue(serieDerriereLaCible(30) > 0, "témoin : à 30 ms, la série est vue"); + assertEquals(0, serieDerriereLaCible(450), 1e-9, + "prouvé : le même client qui annonce 450 ms de ping n'est plus vu (fenêtre 16 ticks au lieu de 8)"); + } + + // --- C15 : vitesse 0,40 en l'air et Timer 1,09 non vus --------------------------------------------------------- + + private static EtatMouvement pas(double dxz, boolean sol) { + return new EtatMouvement(dxz, 0, 1, sol, sol, true, false, false, 0, 0, false, false); + } + + private double vitesse(double dxzAir, double dxzSol, int cycle, int ticks) { + cfg.mode(Controle.VOL, Mode.OFF); + cfg.mode(Controle.NO_FALL, Mode.OFF); + moteur = new Moteur(cfg); + double total = 0; + for (int i = 0; i < ticks; i++) { + boolean sol = cycle > 0 && i % cycle == 0; + total += points(moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), pas(sol ? dxzSol : dxzAir, sol)), + Controle.VITESSE); + } + return total; + } + + @Test + void FAILLE_C15_bhopA040BlocParTickNestJamaisVu() { + // 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (un sprint-saut honnête fait en moyenne ~0,28 à 0,33). + assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9); + } + + @Test + void FAILLE_C15_speedAuSolA037BlocParTickNestJamaisVu() { + assertTrue(vitesse(0.45, 0.45, 1, 200) > 0, "témoin : 0,45 au sol (+50 %) est vu"); + // 0,37 au sol : +23 % sur le sprint (0,30), l'excès (0,06/tick) reste sous le tampon de 1,5 bloc / 20 ticks. + assertEquals(0, vitesse(0.37, 0.37, 1, 400), 1e-9); + } + + private double timer(long intervalleMs, int secondes) { + moteur = new Moteur(cfg); + double total = 0; + for (long t = 0; t < secondes * 1000L; t += intervalleMs) { + total += points(moteur.paquetMouvement(joueur, 10_000 + t, EtatJoueur.normal()), Controle.TIMER); + } + return total; + } + + @Test + void FAILLE_C15_timerA109NestJamaisVu() { + assertTrue(timer(40, 10) > 0, "témoin : 25 paquets/s (timer 1,25) est vu"); + assertEquals(0, timer(46, 30), 1e-9, "prouvé : 21,7 paquets/s (timer 1,09) pendant 30 s, aucun point"); + } +}