Leaf Leaf Mod Analyzer

FastBreak Block Destruction Exploit

Fast_Break_Exploit Exploits HIGH +8 score

🎮 Minecraft Gameplay Impact

In survival Minecraft, breaking a block requires a calculated duration based on the block hardness, the tool used, and active status effects (such as Haste or Mining Fatigue). During block breaking, the client dispatches PlayerActionC2SPacket with action types START_DESTROY_BLOCK, ABORT_DESTROY_BLOCK, and STOP_DESTROY_BLOCK. On the server side, ServerPlayerInteractionManager.processBlockBreakingAction() counts the elapsed ticks between start and stop actions, computing cumulative progress via calcBlockBreakingDelta(). The server only authorizes destruction if the progress reaches 1.0 (100%).

In the inspected exploit module (com.example.timer.mixin.ServerPlayerInteractionManagerMixin), the method timer$scaleStopValidation acts as a server-side compensation hook for the Timer speed multiplier. When STOP_DESTROY_BLOCK arrives, the mixin calculates scaled ticks by multiplying elapsed ticks by TimerState.get().tickMultiplier() (scaledTicks = Math.max(1, Math.round((this.field_14000 - this.field_20326) * multiplier))). If the resulting mining progress reaches 0.7F (70%), the method immediately calls this.method_21717(pos, sequence, "destroyed") and cancels vanilla processing via ci.cancel(), effectively lowering the required mining duration by 30% in addition to the tick speed multiplier.

Because ServerPlayerInteractionManager resides in server-side game logic, this mixin only takes effect in singleplayer worlds, local integrated LAN hosts, or when installed directly on a server. On a remote multiplayer server, the remote server conducts authoritative validation, ignoring client-side mixins on server classes. Pure client-side FastBreak cheats targeting remote servers typically hook into ClientPlayerInteractionManager to eliminate the 5-tick blockBreakDelay or manipulate client-side packet dispatching.

In legitimate modding, event libraries such as Fabric API (ServerPlayerGameModeMixin) also inject into processBlockBreakingAction to invoke event callbacks like AttackBlockCallback and PlayerBlockBreakEvents.Before, but do not modify destruction progress or invoke finishBlockBreakingAction (method_21717).

🔍 Functions & APIs Analyzed

ServerPlayerInteractionManager.method_14263 / processBlockBreakingAction

Validates incoming block-breaking actions and elapsed ticks on the server side.

ServerPlayerInteractionManager.method_21717 / finishBlockBreakingAction

Finalizes block destruction and updates the world block state.

BlockState.method_26165 / calcBlockBreakingDelta

Computes per-tick block destruction progress based on tool stats and block hardness.

⚙️ Decompiled Representation (Vineflower View) 

@Mixin(class_3225.class)
public abstract class ServerPlayerInteractionManagerMixin {
   @Shadow
   protected class_3218 field_14007;
   @Shadow
   protected class_3222 field_14008;
   @Shadow
   private boolean field_14003;
   @Shadow
   private int field_20326;
   @Shadow
   private class_2338 field_20327;
   @Shadow
   private int field_14000;
   @Shadow
   private boolean field_20328;
   @Shadow
   private class_2338 field_20329;
   @Shadow
   private int field_20330;

   @Shadow
   public abstract void method_21717(class_2338 var1, int var2, String var3);

   @Inject(method = "method_14263", at = @At("HEAD"), cancellable = true)
   private void timer$scaleStopValidation(class_2338 pos, class_2847 action, class_2350 direction, int worldHeight, int sequence, CallbackInfo ci) {
      if (action == class_2847.field_12973) {
         float multiplier = TimerState.get().tickMultiplier();
         if (multiplier != 1.0F) {
            if (this.field_14008.method_56093(pos, 1.0) && pos.method_10264() <= worldHeight && pos.equals(this.field_20327)) {
               class_2680 blockState = this.field_14007.method_8320(pos);
               if (blockState.method_26215()) {
                  ci.cancel();
               } else {
                  int scaledTicks = Math.max(1, Math.round((this.field_14000 - this.field_20326) * multiplier));
                  float progress = blockState.method_26165(this.field_14008, this.field_14008.method_51469(), pos) * (scaledTicks + 1);
                  this.field_14003 = false;
                  this.field_14007.method_8517(this.field_14008.method_5628(), pos, -1);
                  if (progress >= 0.7F) {
                     this.method_21717(pos, sequence, "destroyed");
                  } else if (!this.field_20328) {
                     this.field_20328 = true;
                     this.field_20329 = pos;
                     this.field_20330 = this.field_20326;
                  }

                  ci.cancel();
               }
            }
         }
      }
   }
}

🛡️ Bytecode Signature & Static Detection

The detector inspects class bytecode for Mixin injection annotations targeting server-side block destruction processing, combined with direct invocations of destruction finalization or delta progress calculation APIs:

  • An injection annotation (@Inject, @ModifyReturnValue, @ModifyExpressionValue, @Redirect, or @Overwrite) targeting method_14263 (processBlockBreakingAction).
  • An invocation to block destruction or progress methods: method_21717 (finishBlockBreakingAction / destroyBlock) or method_26165 (calcBlockBreakingDelta).

This combination detects routines that recalculate or scale mining ticks to trigger premature block destruction. The rule focuses specifically on server-side interaction processing (ServerPlayerInteractionManager), which executes in singleplayer worlds, integrated LAN hosts, or when installed directly on a server.