Security

// Creer un limiteur de 20 clics par seconde (champ de la classe)
private final GuiRateLimiter chestRateLimiter = new GuiRateLimiter(20);

// A chaque action joueur :
UUID uid = player.getGameProfile().getId();
if (!chestRateLimiter.check(uid)) {
    // Trop de clics — rejeter silencieusement
    LOGGER.warn("[AntiDupe] Rate-limited {}", player.getName());
    return;
}
// ... traiter l'action

// A la deconnexion du joueur :
chestRateLimiter.clear(uid);

// 1. Snapshot AVANT l'operation
ItemStack[] containerSnap = ItemIntegrityValidator.snapshot(container);
ItemStack   cursorSnap    = cursor.isEmpty() ? ItemStack.EMPTY : cursor.copy();
ItemStack[] invSnap       = ItemIntegrityValidator.snapshotPlayerInventory(player);

// 2. Effectuer l'operation (modifier container, cursor, inventaire joueur)
doOperation(container, cursor, player);

// 3. Valider — rejeter si des items ont ete crees
if (!ItemIntegrityValidator.validate(containerSnap, container,
        cursorSnap, cursor, invSnap, player)) {
    // Duplication detectee — restaurer l'etat
    ItemIntegrityValidator.rollback(container, containerSnap, player, invSnap);
    // Re-persister le conteneur si necessaire
    persistContainer(containerSnap);
    return;
}

// 4. Persister — aucune duplication
persistContainer(container);

// Champ de la classe
private final ContainerLock containerLock = new ContainerLock();

// Proteger une operation sur le coffre d'une faction
synchronized (containerLock.getLock(factionInfo.id)) {
    handleChestOperation(player, fm, factionInfo);
    sendChestFullState(player, factionInfo);
}

// Quand une faction est dissoute :
containerLock.removeLock(factionInfo.id);

[AntiDupe] NomDuJoueur a tente de dupliquer +3 items (coffre de faction)

// Apres avoir detecte une duplication :
int delta = totalApres - totalAvant;
LOGGER.warn("[AntiDupe] Duplication detectee pour {} : +{} items", player.getName(), delta);
DupeAlertManager.alert(player, delta, "coffre de faction");
// Effectuer le rollback...

public class MonGuiHandler {

    // ── Instances des outils EriAPI Security ─────────────────────────────
    // Rate limiter : max 20 clics par seconde
    private final GuiRateLimiter rateLimiter  = new GuiRateLimiter(20);
    // Verrous par conteneur (cle = ID de guilde par exemple)
    private final ContainerLock  containerLock = new ContainerLock();

    public void handleSlotClick(EntityPlayerMP player, String containerId,
                                 ItemStack[] container, ItemStack cursor,
                                 int slotIndex, int button) {

        UUID uid = player.getGameProfile().getId();

        // 1. Rate limit — rejeter si trop de clics
        if (!rateLimiter.check(uid)) {
            LOGGER.warn("[AntiDupe] Rate-limited {}", player.getName());
            sendFullState(player, container);
            return;
        }

        // 2. Acces concurrent serialise par conteneur
        synchronized (containerLock.getLock(containerId)) {

            // 3. Snapshot AVANT l'operation
            ItemStack[] containerSnap = ItemIntegrityValidator.snapshot(container);
            ItemStack   cursorSnap    = cursor.isEmpty() ? ItemStack.EMPTY : cursor.copy();
            ItemStack[] invSnap       = ItemIntegrityValidator.snapshotPlayerInventory(player);

            // 4. Effectuer l'operation metier
            doSlotClick(container, cursor, player, slotIndex, button);

            // 5. Valider l'integrite
            if (!ItemIntegrityValidator.validate(containerSnap, container,
                    cursorSnap, cursor, invSnap, player)) {
                // Duplication detectee
                int totalBefore = ItemIntegrityValidator.countItems(containerSnap)
                        + (cursorSnap.isEmpty() ? 0 : cursorSnap.getCount())
                        + ItemIntegrityValidator.countItems(invSnap);
                int totalAfter  = ItemIntegrityValidator.countItems(container)
                        + (cursor.isEmpty() ? 0 : cursor.getCount())
                        + ItemIntegrityValidator.countPlayerInventory(player);
                int delta = totalAfter - totalBefore;

                LOGGER.warn("[AntiDupe] DUPE DETECTEE ! Joueur: {} delta: +{}",
                    player.getName(), delta);

                // 6. Alerter les admins
                DupeAlertManager.alert(player, delta, "conteneur-" + containerId);

                // 7. Rollback
                ItemIntegrityValidator.rollback(container, containerSnap, player, invSnap);
                persistContainer(containerId, containerSnap); // re-persister l'etat revenu
                return;
            }

            // 8. Pas de duplication — persister
            persistContainer(containerId, container);
        }

        // Envoyer le nouvel etat au client
        sendFullState(player, container);
    }

    // A appeler sur PlayerLoggedOutEvent
    public void onPlayerDisconnect(EntityPlayerMP player) {
        rateLimiter.clear(player.getGameProfile().getId());
    }

    // A appeler quand le conteneur est supprime definitvement
    public void onContainerDeleted(String containerId) {
        containerLock.removeLock(containerId);
    }
}