Mixed Boolean Arithmetic (MBA): How Obfuscators Hide Numbers

Ordinary code mixes two worlds that are usually kept apart: arithmetic (+, -, *) and bitwise/boolean (^, &, |, ~) operators. MBA deliberately combines them into expressions that are *algebraically equivalent* to a simple operation but structurally alien. The classic example — addition rewritten with XOR and AND:

x + y  ==  (x ^ y) + 2 * (x & y)

# intuition: (x ^ y) is addition WITHOUT carries;
# (x & y) is exactly the bits that carry, shifted left once (x2).
# add them back and you've reconstructed x + y — for every integer.

Because it's a true identity, you can substitute it anywhere x + y appears and the program behaves *exactly* the same — but the + is gone, and so is any chance of a quick read.

Here are the workhorse MBA identities. Every one held across 20,000 random (x, y) pairs including negatives — real output, not hand-waving:

import random

def holds(f, g, n=20000):
    return all(f(x, y) == g(x, y)
               for x, y in ((random.randint(-1000, 1000),
                             random.randint(-1000, 1000)) for _ in range(n)))

print(holds(lambda x, y: x + y, lambda x, y: (x ^ y) + 2*(x & y)))  # True
print(holds(lambda x, y: x ^ y, lambda x, y: (x | y) - (x & y)))    # True
print(holds(lambda x, y: x & y, lambda x, y: (x | y) - (x ^ y)))    # True

The same trick erases literal constants. Instead of 1337 sitting in the code for a text search to find, express it as the result of an MBA operation over two split values — 1337 = 1000 + 337, then apply the addition identity:

# before: the constant is right there
LICENSE = 1337

# after: 1337 never appears — it's computed by an MBA identity
LICENSE = (1000 ^ 337) + 2 * (1000 & 337)   # == 1337, tested

assert LICENSE == 1337   # holds

Now a grep 1337 finds nothing, and the two operands (1000, 337) are arbitrary — an obfuscator can pick different splits every build, so the same constant looks different each time. Scale that across every literal and comparison in a licensing routine and the logic stops being readable at a glance.

You might think a reverse-engineer just simplifies it back. In practice that's genuinely hard, for a specific reason: general MBA simplification is a known-difficult problem. Standard compiler constant-folding and peephole optimizers don't reduce mixed boolean-arithmetic expressions, because they don't have algebraic rules that cross the arithmetic/bitwise boundary. Recovering the original requires specialized MBA solvers (tools like SSPAM, Arybo, or SMT-assisted simplifiers), and even those struggle as expressions get deep and nonlinear.

• Size and speed: each substitution replaces one op with several, and nesting multiplies that — heavy MBA can noticeably grow the code and slow hot loops, so it's best applied to *sensitive* math (keys, checks), not every arithmetic line.
• Correctness is exact — if the identities are exact. The identities above are provably equal for Python's arbitrary-precision integers; a good obfuscator only uses proven identities so behavior never changes.
• It's one layer. MBA hides *numbers and math*; it does nothing for names, strings, or control flow. Real protection layers it with the other techniques below.

Doing this by hand is tedious and error-prone — you have to keep every substitution provably equal. Our free Python Obfuscator applies MBA-style integer encoding as one of its layers, so the constants and arithmetic in your code come out as opaque expressions automatically, with the output still standalone, runnable Python.

MBA is strongest as part of a layered approach. Pair it with the other transforms, each covered in its own guide: control-flow flattening, identifier renaming, junk-code injection, and string encryption. The full picture is in Python obfuscation explained.