Secure and Secure+ Minecraft mods

The Minecraft counterpart of Nebula's Secure and Secure+ badges for Among Us. You mark your mod in its MANIFEST.MF; Nebula detects the marker when the jar is uploaded and shows the badge. Works for Fabric, Quilt, Forge and NeoForge mods.

Overview

LevelMarker in META-INF/MANIFEST.MFWhat it means
NormalnoneDelivered by Nebula like any mod. A server's mods go to its Nebula Server agent, a player's mods go to their launcher.
SecureNebula-Secure: trueFor Nebula only. Your mod can check nebula.managed and refuse to run when it was not delivered by Nebula.
Secure+Nebula-InMemory: trueSecure, and a client-side mod that is never given to a server or to whoever hosts it. Only players' games get it.
Client-onlyenvironment: client in fabric.mod.json / quilt.mod.json, or Nebula-Side: clientThe mod does nothing on a server, so Nebula never sends it to one.

How a mod is delivered

  • Your jar is stored encrypted on the panel and scanned for malware on upload.
  • Each delivery is encrypted again for the one player or server that gets it (AES-256-GCM, a fresh key every time) and signed by the panel. The receiving launcher or agent checks the signature before it uses the file.
  • Every delivered copy carries a hidden per-account watermark, so a leaked jar points back to the account it was delivered to (Admin › Trace a leak).
  • A mod is written into the game's mods folder only while the game or server runs, and removed when it stops. Anything that was already in that folder is moved to nebula-stash and never loaded.

Secure

Add the marker to your jar's manifest. With Gradle (Fabric Loom, Quilt Loom, ForgeGradle, NeoGradle):

jar {
    manifest {
        attributes(
            'Nebula-Secure': 'true'
        )
    }
}

With Maven (maven-jar-plugin):

<manifestEntries>
    <Nebula-Secure>true</Nebula-Secure>
</manifestEntries>

Nebula starts every game and every server it runs with -Dnebula.managed=true. A copy someone drops into their own game does not have it, so your mod can switch itself off:

// Fabric / Quilt
public class MyMod implements ModInitializer {
    @Override public void onInitialize() {
        if (!"true".equals(System.getProperty("nebula.managed"))) {
            throw new IllegalStateException("My Mod is only available through Nebula.");
        }
        // ... your setup
    }
}

// Forge / NeoForge: do the same check in the @Mod class constructor.
Secure is a load-time gate, not encryption. Someone who edits your jar can remove the check. It stops casual copy-and-drop reuse, and the watermark traces anything that does leak.

Secure+

Add Nebula-InMemory instead of (or as well as) Nebula-Secure:

jar {
    manifest {
        attributes(
            'Nebula-InMemory': 'true'
        )
    }
}

A Secure+ mod is a client-side mod. Nebula gives it to players' games only: the Nebula Server agent is never sent it, so the person who hosts the server never holds a copy. Design it so the server does not need it, which means a Fabric/Quilt "environment": "client" mod or a Forge/NeoForge mod that is client-side only.

Do not mark a mod Secure+ if the server must run it. A server that needs your mod's blocks, items or logic will not have it, and players will not be able to join. Use Secure for a mod that both sides need.

Secure+ implies Secure: the nebula.managed check is available too, and the upload shows the Secure+ badge.

Why not "from memory" as in Among Us? Among Us mods are .NET assemblies the launcher can hand to the game without a file. Minecraft's mod loaders (Fabric, Quilt, Forge, NeoForge, Paper) read mod jars from files, so a jar has to exist on disk at the moment the game opens it. Nebula keeps that time as short as it can (see below) and never leaves a mod there afterwards.

Client-only mods

A mod that only matters on a player's game is never sent to a server, with or without a Nebula marker. Nebula reads "environment": "client" from fabric.mod.json (Quilt: "minecraft": { "environment": "client" }), or this manifest line for any loader:

Nebula-Side: client

On a server

A server's mods are delivered to its Nebula Server agent, encrypted and signed, held in memory and written into the mods (or plugins) folder only when the server starts. Once the server has loaded its mods, it holds the jars open itself, and the agent takes the files out of the folder at once. From then on there is no mod file to copy from the folder, and nothing is left there when the server stops.

  • Mod loaders (Fabric, Quilt, Forge, NeoForge): the files are removed when the server reaches "Preparing level".
  • Plugin servers (Paper, Purpur and others): when the server reports "Done".
  • On Linux hosting this works as described. On Windows the system does not allow a file that is in use to be deleted, so the files stay until the server stops, and the agent says so in its console.
  • Secure+ and client-only mods are not sent to the agent at all.

The setting

In a Minecraft server's Server tab (web panel, desktop launcher and Android) there is a switch, Take the mod files out once loaded. It is on by default. Turn it off only if a mod misbehaves because its file is gone after loading (a mod that reopens its own jar later); the mod then stays in the folder while the server runs, like before, and is still removed when the server stops.

What Nebula checks

When a jar is uploaded Nebula reads META-INF/MANIFEST.MF and the loader's descriptor. It shows the Secure or Secure+ badge from the markers, and marks the mod client-only when the descriptor says so. It is never a manual claim: the badge always comes from the file.

Honest limits

  • Nothing that runs on someone else's machine is truly un-extractable. A running mod can be dumped from the game's memory, and a server's host can read its own process.
  • What Nebula gives you: files that are encrypted in storage and in transit, signed, present on disk for the shortest time, gone from the folder on a server once loaded, removed on exit, and traceable to an account by the watermark if a copy still leaks.
  • Secure+ keeps your mod off servers entirely, which is the strongest protection available for a client-side mod.