Constants Disintegration

Constants disintegration breaks the numbers in your code into chains of arithmetic, logical, and conditional operations, so the original values never appear in the binary.

.NET

Start free

See it in ByteHide Shield

TL;DR

Constants disintegration replaces the literal numbers in your application with dynamic operations that compute those values at runtime. The constant 42 is never stored as 42. It is produced by a chain of operations, so an attacker scanning the binary cannot find or recognize it.

Definition

What is constants disintegration?

Constants disintegration is an obfuscation technique that removes literal numeric values from compiled code by replacing each one with a computation that produces it.

Numbers carry meaning. A buffer size, a magic value, a bit mask, a license tier: these constants tell an attacker how an algorithm works, and they are easy to find in a binary.

Constants disintegration breaks each number apart into arithmetic, logical, and conditional operations that evaluate to the same value at runtime. The constant is never stored directly, so it cannot be found by scanning or recognized by analysis.

Mechanism

How constants disintegration works

Constants disintegration transforms each literal into a dynamic computation:

Arithmetic decomposition. A value is expressed as a chain of arithmetic operations that reach it.
Logical and conditional operations. Bitwise logic and conditional steps are mixed in so the computation resists simplification.
Dynamic evaluation. The value is produced at runtime, never stored as a literal.

Each disintegration is verified to compute exactly the original value.

Example

Constants disintegration example

The same buffer settings, before and after constants disintegration. The runtime values are identical.

Original

A meaningful constant sits in the code as a plain number. An attacker finds it and understands what it controls.

Disintegrated

The same constant is now a chain of operations computed at runtime. The number never appears, and the intent is hidden.

OriginalBuffer.cs

class Buffer
{
    const int Capacity = 4096;
    const int Threshold = 256;
}

DisintegratedBuffer.cs

class Buffer
{
    static readonly int Capacity = (1 << 12);
    static readonly int Threshold = ((1 << 7) << 1);
}

Use cases

When to use constants disintegration

Constants disintegration is most useful when your .NET application:

Uses meaningful numeric constants that reveal how logic works.
Contains buffer sizes, masks, thresholds, or magic values worth hiding.
Has already been renamed and string-encrypted and needs numeric data protected too.

It pairs with string encryption and name obfuscation: together they hide the names, the text, and the numbers an attacker reads.

Platform availability

Constants disintegration and the .NET platform

.NET
Disintegration of integer constants into dynamic operations. On other platforms, equivalent numeric protection is provided by constant mutation and arithmetic obfuscation.

Frequently asked questions

What is constants disintegration?

Constants disintegration is a .NET obfuscation technique that replaces literal numbers in your code with chains of arithmetic, logical, and conditional operations, so the original values never appear in the binary.

Does constants disintegration affect performance?

It adds a small overhead, since constants are computed instead of stored. The level is configurable to balance protection and speed.

Does constants disintegration change results?

No. Every disintegration is verified to compute exactly the original value.

How is it different from constant mutation?

They share a goal on different platforms. Constants disintegration is the .NET protection. Constant mutation is the equivalent on Android.

Which platforms support constants disintegration?

Constants disintegration applies to .NET. Android uses constant mutation for the equivalent protection.