Skip to content
← All posts
· Delta1 Labs ObfuscationNebula

How opaque predicates frustrate automated deobfuscators

Why always-true predicates and junk branches defeat de4dot-style tools — with real C#, representative IL, the perf/size trade-off, and which Nebula tier does it.

Rename everything, encrypt every string, and a decompiler still hands an attacker one thing intact: the shape of your logic. Branches, loops and guard clauses survive compilation almost perfectly, and that shape is most of what makes decompiled code readable. Control-flow flattening attacks the shape directly. Opaque predicates and bogus control flow attack something subtler — the attacker’s tools. They plant branches that look meaningful, run predictably, and resist the automated passes a deobfuscator uses to clean house.

This is a deep explainer: what an opaque predicate actually is at the IL level, why a generic deobfuscator like de4dot cannot simply fold it away, and what you pay in size and speed to use it.

What a decompiler does for free

Give a decompiler this method and it gives back something almost identical to the source:

decimal ApplyDiscount(decimal price, int tier)
{
    if (tier >= 3)
        return price * 0.80m;
    return price;
}

The IL is a single conditional branch over two basic blocks. A decompiler walks the control-flow graph, matches the brtrue/blt pattern to an if, and reconstructs the source. Nothing here is hidden. The graph is the readability — so the job is to put edges in that graph a tool cannot trust.

The idea: a branch whose answer is already known

An opaque predicate is a boolean expression whose value is fixed when Nebula rewrites the assembly, but which a static analyzer cannot cheaply prove. The classic form is a number-theoretic identity that is true for every integer:

x * (x + 1) is always even — so (x * (x + 1)) % 2 == 0 is always true, for any x.

A human sees it in a second. A decompiler sees a multiply, an add, a remainder and a compare over a value it does not know, and has no constant to fold. So it prints the branch verbatim, including the dead arm Nebula filled with plausible-looking junk.

Here is the method after an opaque predicate has been woven in (decompiled back to C# to show the effect):

decimal ApplyDiscount(decimal price, int tier)
{
    int x = tier;
    if ((x * (x + 1)) % 2 == 0)        // opaque-true: always taken
    {
        if (tier >= 3)
            return price * 0.80m;
        return price;
    }
    // bogus arm: never executes, but the tool cannot prove it
    return price * (decimal)((x ^ 0x5F) + 1);
}

The real logic is now nested inside a guard that always passes, sitting beside a bogus return the analyzer must keep because it cannot rule it out. Multiply this across a method and the reconstructed code is a thicket of conditions that all look load-bearing.

At the IL level

The predicate is cheap — a handful of integer ops and a branch. Representative IL for the inserted guard, with the real body under IL_0015 and the bogus block under IL_002a:

// int x = tier;
IL_0000: ldarg.1
IL_0001: stloc.0          // x

// (x * (x + 1)) % 2 == 0  -> always true
IL_0002: ldloc.0
IL_0003: ldloc.0
IL_0004: ldc.i4.1
IL_0005: add
IL_0006: mul              // x * (x + 1)  — provably even
IL_0007: ldc.i4.2
IL_0008: rem
IL_0009: brtrue IL_002a   // if odd -> bogus; proven impossible at runtime

IL_0015: ldarg.1          // --- real body ---
IL_0016: ldc.i4.3
// ... if (tier >= 3) return price * 0.80m; else return price;

IL_002a: ldarg.0          // --- bogus block: dead, but opaque ---
// ... return price * ((x ^ 0x5F) + 1);

The crucial line is IL_0009. At runtime rem is always 0, so brtrue never jumps and the bogus block is unreachable. But unreachability here is a theorem, not a syntactic fact. To delete IL_002a a tool must prove x * (x + 1) is even for all int — including overflow wraparound — which no generic pass attempts.

An opaque-true predicate adds a dead branch a deobfuscator cannot prove unreachable Original graph After opaque predicate tier >= 3 ? price*0.80 price x*(x+1) even ? real body bogus arm always never Runtime takes only the solid edge. A static tool must keep the dashed edge — it cannot prove the predicate constant.

Why de4dot-style tools cannot just strip them

Generic deobfuscators are, at heart, pattern matchers with a constant folder. They work spectacularly on known obfuscators because those emit predicates in a fixed, recognisable shape — fold the constant, prove the branch dead, delete it, repeat. That strategy breaks on opaque predicates for three reasons.

1. There is no constant to fold

(x * (x + 1)) % 2 == 0 contains no literal that resolves to a fixed boolean. The truth is a property of integer arithmetic, not a value sitting in the IL. A constant folder has nothing to grab. Proving it would require the tool to carry a small theorem prover and apply number theory — far outside what a general-purpose cleanup pass does, and unsound to guess at.

2. Removing a branch you cannot prove dead is dangerous

A deobfuscator’s prime directive is do not change behaviour. If it deletes a branch it merely suspects is dead and it was wrong, it silently corrupts the program. So when a predicate is not provably constant, the safe move — the only safe move — is to keep it. Opaque predicates weaponise that caution: every one you add is a branch the tool must preserve.

3. Pattern diversity defeats signatures

If every predicate were x*(x+1)%2, a tool author would hard-code a rule for it. Nebula draws from a family — parity identities, 7y² − 1 never being a perfect square, sum-of-squares facts, and predicates seeded from values that only exist at runtime — and varies them per site using the stable project seed. There is no single signature to match, and a predicate built on a runtime value has no static answer at all.

Turning it on

Bogus control flow lives under the controlFlow block in nebula.config.json:

{
  "renaming": { "mode": "dictionary" },
  "encryptStrings": true,
  "controlFlow": {
    "enabled": true,
    "opaquePredicates": true,
    "bogusBranchDensity": "medium",
    "predicateFamilies": ["parity", "quadratic", "runtime-seeded"]
  }
}

Then run the obfuscator over your built assembly:

nebula protect ./bin/Release/net8.0/Billing.dll \
  --config nebula.config.json \
  --out ./protected/

bogusBranchDensity is the dial that matters. low sprinkles predicates at method entry points; high wraps interior blocks and nests bogus regions. Density trades directly against size and speed, so tune it to the method, not the whole assembly — which is what keepList entries and per-namespace overrides are for.

The cost, honestly

Opaque predicates are not free, and anyone who tells you otherwise is selling you a surprise in production.

  • Size. Each predicate adds a few IL instructions plus a bogus block that must look real. At medium density expect assemblies to grow in the low tens of percent; high can more than double method bodies in hot namespaces.
  • Speed. The predicate itself is a few integer ops — negligible in isolation. The real cost is indirect: bigger methods blow the JIT’s inlining budget and pollute the instruction cache. A method that was inlined before may stop being inlined after. Never put high-density bogus flow inside a tight loop; protect the method that calls into the loop instead.
  • Debuggability. Protected stack traces and decompiled dumps become genuinely harder to read — for you as well as an attacker. Keep your renaming map and symbol artifacts so you can retrace production traces.

The mental model: opaque predicates do not make your code impossible to understand. They make automated understanding unreliable, which raises the cost of attack from “run de4dot, read the output” to “hand-analyse every branch and decide which are real.” For most IP that difference is the whole game.

Which tier

Basic control-flow obfuscation — opaque predicates at low-to-medium density — is a Pro feature, alongside code virtualization and method encryption. The aggressive control-flow tier, with high predicate density, deeply nested bogus regions and correlated predicate networks where several opaque conditions reference a shared runtime invariant, is Enterprise. Correlation is what pushes it from “survives a generic pass” to “survives a determined human with a disassembler” — which is why it is gated higher.

Where it fits

Opaque predicates are a layer, not a strategy. Rename to kill the names, encrypt strings and constants to kill the literals, flatten control flow to kill the shape — and then add bogus flow so the tools that would undo all of the above cannot run unattended. Each layer raises the floor; together they turn a five-minute decompile into a project an attacker has to decide is worth their week. Start at medium, measure the two numbers that matter — assembly size and the throughput of your hottest path — and move the dial from there.

Try Nebula.NET

Harden your .NET code in minutes — start with the free edition.