Java Bytecode Obfuscation

Nebula Obfuscator

Protect your Java applications with advanced bytecode obfuscation engineered for security, stability and professional pipelines.

Get Started See it in action

Lines protected

Avg. protection layers

Security rating

Main Features

A complete obfuscation pipeline that turns reverse engineering your Java code into a nightmare.

Core Features

Name Obfuscation

Rename classes, fields, and methods without destroying the hierarchy.

Paper, Bungee & Velocity Support

Natively supports Minecraft plugins & mods without breaking anything.

Documentation

Comes with documentation on how to write a proper authentication system.

Code Structure Changes

Method Inlining

Inline eligible method calls to obscure control flow and reduce call-graph clarity.

Local Variable Table Obfuscation

Pack every two local 32-bit integers into one 64-bit local long.

Line Number Obfuscation

Scramble line number metadata to make stack traces harder to map back to source.

Useless Reference Injection

Dead code insertion like never seen before.

Data Obfuscation

String Encryption

Use AES-CBC, SHA256 & MD5 and lookup tables to hide string literals.

Number Encryption

Encrypt numbers with class salts.

Constant Export & Encryption

Export all string constants into one resource file.

Resource Encryption

Encrypt, bundle & compress resources.

Annotation Encryption

Encrypt strings & numbers inside annotations.

Method Salting

Pass keys through method parameters.

References & Flow Obfuscation

Switch to Ifs

Convert switch table to ifs to make reverse engineering harder.

Reference Obfuscation

Hide method & field references.

Control Flow Flattening

Flatten control flow & shuffle blocks.

Exception Flow Obfuscation

Add dead exception handlers to mess with decompilers.

Maximum Security

Virtual Machine Protection

Interpret code through a proprietary VM layer.

See Nebula in Action

See how Nebula transforms your Java code into something completely unreadable, while maintaining all its functionality.

Original Code

@Override
public void keyPressed(KeyEvent e) {
    switch (e.getKeyCode()) {
        case 39: {
            if (ThreadsController.directionSnake == 2) break;
            ThreadsController.directionSnake = 1;
            break;
        }
        case 38: {
            if (ThreadsController.directionSnake == 4) break;
            ThreadsController.directionSnake = 3;
            break;
        }
        case 37: {
            if (ThreadsController.directionSnake == 1) break;
            ThreadsController.directionSnake = 2;
            break;
        }
        case 40: {
            if (ThreadsController.directionSnake == 3) break;
            ThreadsController.directionSnake = 4;
            break;
        }
    }
}

Obfuscated Code

/*
 * Unable to fully structure code
 * Enabled aggressive block sorting
 * Enabled unnecessary exception pruning
 * Enabled aggressive exception aggregation
 */
@Override
public void keyPressed(KeyEvent var1_1) {
    var4_2 = 0;
    var3_4 = b.D("\ue01e", (Integer)-1380990887);
    var2_3 = b.D("\ue02e", (Integer)-1380990888, (Object)var1_1);
    v0 = var3_4;
    var4_2 = var2_3 == (-1889457531 | v0) - (-1889457531 & v0) ? 532838301 : 1363449407;
    ** GOTO lbl19
    while (true) {
        var4_2 = 1406182180;
        if (true) ** GOTO lbl19
        break;
    }
    block24: while (true) {
        var4_2 = 1752419759;
        ** GOTO lbl19
        while (true) {
            var4_2 = -1927500345;
            if (true) ** GOTO lbl19
            break;
        }
        block26: while (true) {
            var4_2 = 645629358;
lbl19:
            // 5 sources

            block27: while (true) {
                block28: {
                    v1 = var4_2;
                    switch ((v1 | 2031780358) - (v1 & 2031780358)) {
                        case 677254201: {
                            v2 = var3_4;
                            if (var2_3 == (-1889457530 | v2) - (-1889457530 & v2)) ** continue;
                            var4_2 = 1131571824;
                            continue block27;
                        }
                        case 1600194472: {
                            v3 = var3_4;
                            if (b.D("\ue016", (Integer)-1380990895) == (-1889457501 | v3) - (-1889457501 & v3)) continue block24;
                            var4_2 = 152800699;
                            continue block27;
                        }
                        case 1011975516: {
                            v4 = var3_4;
                            b.D("\ue00e", (Integer)-1380990882, (int)((-1889457502 | v4) - (-1889457502 & v4)));
                            continue block24;
                        }
                        case 979953782: {
                            v5 = var3_4;
                            if (var2_3 == (-1889457529 | v5) - (-1889457529 & v5)) ** continue;
                            ** break;
                        }
                        case -200921151: {
                            v6 = var3_4;
                            if (b.D("\ue01c", (Integer)-1380990885) == (-1889457502 | v6) - (-1889457502 & v6)) continue block24;
                            var4_2 = 515781560;
                            continue block27;
                        }
                        case 1879117757: {
                            v7 = var3_4;
                            b.D("\ue000", (Integer)-1380990896, (int)((-1889457500 | v7) - (-1889457500 & v7)));
                            continue block24;
                        }
                        case 1725494683: {
                            v8 = var3_4;
                            if (b.D("\ue018", (Integer)-1380990881) == (-1889457503 | v8) - (-1889457503 & v8)) continue block24;
                            var4_2 = 1162544986;
                            continue block27;
                        }
                        case 850545794: {
                            v9 = var3_4;
                            b.D("\ue00c", (Integer)-1380990884, (int)((-1889457501 | v9) - (-1889457501 & v9)));
                            continue block24;
                        }
                        case 1738846654: {
                            v10 = var3_4;
                            b.D("\ue00a", (Integer)-1380990886, (int)((-1889457503 | v10) - (-1889457503 & v10)));
                            continue block24;
                        }
                        default: {
                            continue block27;
                        }
lbl74:
                        // 1 sources

                        var4_2 = 1626691417;
                        continue block27;
                        case 717889826: {
                            v11 = var3_4;
                            if (b.D("\ue01a", (Integer)-1380990883) == (-1889457500 | v11) - (-1889457500 & v11)) continue block24;
                            var4_2 = 1269354116;
                            continue block27;
                        }
                        case 435148127: {
                            v12 = var3_4;
                            if (var2_3 == (-1889457528 | v12) - (-1889457528 & v12)) continue block26;
                            break block28;
                        }
                        case 292114345: {
                            return;
                        }
                        case 757744865: 
                    }
                    continue block24;
                }
                var4_2 = 1412482791;
            }
            break;
        }
        break;
    }
}

Samples

Here are a few examples of Nebula-obfuscated applications, before and after being obfuscated by Nebula.

Name Original Nebula Info
CrackME Not Available Download A crack me jar to test the strength of Nebula.
SnakeGame Download Download A Snake Game from GitHub. View source on GitHub

Pricing Plans

One-time payment. Every plan includes the complete Nebula protection pipeline.

Standard

Full protection for short-term or single-release projects.

$35 / 6 months
  • Class, field & method name renaming
  • Annotation & resource encryption
  • Constant exporting to file
  • Control flow flattening
  • Line number mangling
  • Method inlining
  • Number & string encryption
  • Reference obfuscation
  • Switch to if conversion
  • Junk code insertion
  • Code virtualization
  • Miscellaneous obfuscations
Get 6 Months

One-time payment. Free updates for 6 months.