JVM bytecode virtualization · 0x7F

Rewrite bytecode
into a custom VM only Deluxor reads

Deluxor is a next‑generation Java obfuscator and bytecode virtualizer. It lifts selected methods from compiled JARs into a custom VM with its own opcodes, dispatch, and layered interpreters. The goal: raise the time, expertise, and tooling cost of reverse engineering — making Java obfuscation truly effective.

AccountService.java → a.class
VM L2→L3 opcode map
public boolean authenticate(
    String username,
    String password
) {

    if (username == null) {
        return false;
    }

    if (password == null) {
        return false;
    }

    return verify(
        username,
        password,
        apiKey
    );
}
; class a  method a(String,String)Z chunk 0x1F4

0000  VENTER frame[4] guard=deluXor
0006  VARG   r1 <- a[0]
000c  VNULLQ r1      jz → 0x004A
0018  VLDF   r3 <- this.b
; apiKey
001e  VXORK  r2 ^= k[0x1A]
; 0x5F3A9C2D
0026  VWILD  0x7C (III)J
; dispatch
002e  VINVK  #f [r1,r2,r3]
0036  VTRUE  → ret
0050  VLEAVE wipe frame; rotate k

Protection stack

Layered virtualisation, control-flow obfuscation, encrypted constants, runtime guards, and integrity checks — designed to raise analysis cost at every level. This is what makes Deluxor a superior Java obfuscator.

Bytecode virtualization

Selected methods are lifted out of the JVM instruction set into a custom VM with its own opcodes and dispatch. Decompilers see an interpreter loop, not your control flow.

Layered interpreters

Up to three stacked VM layers. Application methods descend through execute-stub wrappers and interpreter kernels, each with independent opcode maps.

Control-flow transformation

Flattening, virtual control-flow graphs, and opaque predicates disrupt recovery of the original branch structure.

String & constant protection

Strings and numeric constants are encrypted and resolved on demand from a protected pool instead of remaining exposed in constant tables.

Runtime guards

Anti-debug inspection, watchdog re-checks, JDWP probing, session-key rotation, replay protection, and agent detection increase resistance against live analysis.

Integrity & verification

VM integrity validation and differential verification help confirm that protected builds preserve intended behaviour.

Multi‑layer VM

Layer #1

Application methods

Original bytecode entry points. Control flow is flattened and prepared for lifting into the virtual machine.

Layer #2

Execute‑stub wrappers

Each virtualized method is wrapped in a stub that handles argument marshalling, stack frame setup, and dispatch to the interpreter kernel.

Layer #3

Interpreter kernel

Custom opcode decode + dispatch loop. Runtime guards (anti-debug, integrity) and key rotation are executed here.

Protection pipeline

01 Load JAR Parse classes
02 Analyse Select methods
03 Transform Rename & encrypt
04 Virtualize L2 / L3 opcodes
05 Guard Runtime checks
06 Verify Structural checks
07 Emit Protected JAR

FAQ

Deluxor processes compiled Java bytecode inside a JAR. Selected methods can be virtualised, constants protected, control flow transformed, and runtime verification added. The original source is never required.
No. No obfuscator or virtualizer can make reverse engineering impossible. The objective is to increase the time, expertise, tooling effort, and overall cost required to understand protected code.
Yes. Virtualized methods execute through an interpreter layer. You decide which methods are protected and how many layers are applied, allowing protection and performance to be balanced per use case.
Verification compares structure and behaviour, but every protected build should still be tested in your own environment before deployment.
Compiled Java bytecode packaged inside JAR files. Deluxor works on class files and does not require access to source code.
No. Deluxor operates on an already compiled JAR and does not require source code modifications or build pipeline changes.

Private beta

Access is currently limited while the platform evolves and verification workflows mature.