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 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Opus 5.5 a révisé 2026-10-16 01:07:49 +02:00
1 Parent bfc8f5719c
révision bbb08a95f8
2 fichiers modifiés
+323

Aucun fichier ne correspond à votre recherche

+64
Voir le fichier
@@ -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<Integer, Object> table = (Map<Integer, Object>) 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();
}
}
}
+259
Voir le fichier
@@ -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<Verdict> 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<Verdict> coup(long t, EtatJoueur etat, double[] oeil, double[] regard, double[] oeilSuivant,
double[] regardSuivant, double xCible, double[][] vues) {
List<Verdict> 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<Verdict> 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<Verdict> 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<Verdict> 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<Verdict> 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");
}
}