---
title: Mystique - An x86 Metamorphic Compiler
author: wK
---
|=-----------------------------------------------------------------------=|
|=-------------=[ Mystique - An x86 Metamorphic Compiler ]=--------------=|
|=------------------------------=[ by wK ]=------------------------------=|
|=--------------------------=[ .vx at pm.me ]=---------------------------=|
|=-----------------------------------------------------------------------=|


--[ Table of contents

1.  Introduction
2.  Background
     2.1 Metamorphism
     2.2 The 'Perfect' Engine
     2.3 The Blueprint
3.  The Story, cont'd
     3.1 The Unrealized Dream
     3.2 Resurrection
4.  The Compiler
     4.1 Frontend
     4.2 IR Bytecode
     4.3 Backend
          4.3.1 Optimization & Transform Cycle
          4.3.2 Behavioral Variability
          4.3.3 The Genome
          4.3.4 Output Modes
5.  The Metamorphic Bundle
     5.1 Infectors
     5.2 Recompilers
     5.3 Integrators
6.  Detectability
7.  Outro
8.  References

--[ 1. Introduction
Mystique  is the realization of a dream project I wanted to create for about
20  years.  It  was supposed to combine the best ideas and techniques of the
turn-of-the-century   Metamorphic  viruses  into  one  engine.  I  tried  to
implement  it  several times over a few years, but never got to finish. When
coding agents emerged last year, I decided to give it another shot.

AI  Disclosure: I am as allergic to 'AI slop' as any other hacker out there,
so  I've given my best efforts to make this project and paper (which I wrote
myself)  worthwhile  for  the Phrack audience. Ideas, architecture and major
design  decisions  were purely human. Code, docs and tests were generated by
the  coding  agent  under  my direction, and were painstakingly debugged and
reviewed by me. I take responsibility for the final product.

The  story  begins  in the late 90's, when I was a teenager enchanted by the
'Computer    Underground',    ultimately   drawn   to   its   cracking   and
reverse-engineering alleys. The VX scene, which seemed quite intimidating at
first,  gradually  grew  on  me.  The thought of writing programs that mimic
biological  organisms  captured my imagination. Programs that were spreading
wildly,  mutating  on each generation and constantly evading 'predators'. It
was Digital Life, realized in code.

Of  all  the  strange viruses I had come across, three utterly blew my mind,
and  I  had  spent  considerable  time  studying  them, almost line-by-line:
MetaPHOR  by  The  Mental  Driller [1], Lexotan32 by Vecna [2], and Zmist by
Z0MBiE  [3][4].  I  first  came across them in Issue #6 of the legendary 29A
magazine.  What  set  them  apart  was  that  they  all  were highly complex
METAMORPHIC viruses.

--[ 2. Background

----[ 2.1 Metamorphism
As  a  technique, Metamorphism grew naturally from Polymorphism. In order to
evade  simple byte-string signature detection, Polymorphic viruses encrypted
their  own body and obfuscated the decryptor differently on each generation.
This  proved successful for a while, until AVs learned to emulate executable
code and wait for the virus to be decrypted in memory - and then catch it.

                                  +-------------+
                                  | polymorphic |
                                  | decryptor   |
            +-------------+       +-------------+
            |             |       |             |
            | plain       |       | encrypted   |
            | virus       |-----> | virus       |
            | body        |       | body        |
            |             |       |             |
            +-------------+       +-------------+

The logical conclusion to this was to make the entire virus body variable. A
Metamorphic  virus  would  typically disassemble its own binary code, mutate
it,  introduce  code  permutations  and  junk  instructions,  and reassemble
itself.  The  concept  may  sound  simple,  but writing a decent metamorphic
engine  is  an  order  (or  two)  of magnitude more complex than the average
polymorphic  engine.  If we were to leave no static bytes (while not relying
on  encryption),  the  entire  mutation process would have to be applied for
both the virus AND the metamorphic engine itself.

            +-------------+        +-------------+
        +---+ virus       |    +-->| new virus   |
        |   +-------------+    |   +-------------+
        |   |             |    |   |             |
        +-->|             +----+   | new         |
            | metamorphic |        | metamorphic |
            | engine      |        | engine      |
        +-->|             +------->|             |
        |   |             |        |             |
        |   +-----+-------+        +-------------+
        |         |
        +---------+

The  only problem was that complex as they were, all the Metamorphic viruses
eventually    got    detected.   Their   binary-level   mutations,   however
sophisticated, still left structural patterns that scanners could learn.


----[ 2.2 The 'Perfect' Engine
This  was  already  the early 2000's, and the world was beginning to change.
The  underground  showed  its  first signs of evaporation, and those viruses
were, eventually, the swan song of a culture that practiced an ancient black
art.  But  I  was  determined  to make a maybe-last big contribution to this
dying  field. Having never written a real virus myself, I planned on writing
the ultimate one. I wanted to stand on the shoulders of giants and declare a
final victory. A truly undetectable virus.

Ah, teen megalomania. I kinda miss it sometimes.

I began to plan this perfect virus engine, drawing inspiration from the work
of  above-mentioned  pioneers,  among others. Unbeknownst to me, herm1t, the
famed VXer (and curator of the late VX Heavens archive), conspired to do the
same.   At   some   point   I  approached  him,  and  we  had  a  series  of
thought-provoking  discussions  on  this  matter,  some  of  which  he later
documented in "Recompiling the metamorphism" [5].

The main problem, as we've both identified, was that traditional metamorphic
viruses  applied  code transformation on the binary/assembly level. This was
only natural, because most viruses were written in asm anyway. herm1t put it
elegantly:

  "the   virus   performs   both  of  the  most  significant  phases  of
  re-compilation  in such a way, like it was trying to build the ship in
  the  bottle,  or  in  the  compiler's  language:  through  a peep hole
  (modifying  a few instructions at a time), leaving out of account both
  the structure and semantic of the code.
  [..]
  It  would be better to use high level language instead of assembly. By
  "high   level"   I  mean  a  possibility  to  (automatically)  extract
  additional  information  from  the  code  (not what it do, but what it
  mean)  rather  than  builtin  support  for  the  features like hashes,
  iterators  or  objects. The special feature of a smart software is its
  ability  to maintain interconnections and meaning of the code and data
  rather than shuffling it like a deck."

So what if we went 'higher' up in the (de)compilation chain? What if instead
of  mutating a MOV or an ADD instruction at a time, we transform the code on
a different level?

What we aimed for was a full Metamorphic Compiler.

The  paper  traces the idea back to as early as 1993, and goes on to outline
the  different  approaches  and tradeoffs that the meta-compiler-writer will
ultimately face.

----[ 2.3 The Blueprint
My  approach  was  to  design  a programming language for viruses, perhaps a
subset  of  C,  that  would  produce  an  Intermediate  Representation  (IR)
bytecode. The bytecode would then be passed to a code generator, which would
produce different code each time.

In  classic  compiler  theory,  the  distinction is between a Frontend and a
Backend:

             +----------+                  +---------+
program.c -->| Frontend |--> program.ir -->| Backend |--> variant1.bin,
             +----------+                  +---------+    variant2.bin,
                                                          ...

The  Frontend  handles lexing, parsing, and IR generation, while the Backend
handles  code  generation:  register  allocation, instruction selection, and
address  fixups.  More  importantly,  the Backend will have total freedom to
select  different  registers,  substitute  equivalent  instructions, reorder
independent operations and insert junk code, producing outputs that share no
syntactic signature.

To illustrate, let's take a look at an example program:

int main() {
    int a;
    int b;

    a = 3;
    b = a + 5;
    if (a > b)
		return a;
    else
		return b;
}

After  passing  it  through  a  Frontend  we  would  get something like this
Three-Address-Code (TAC) Intermediate Representation (IR):

    int main()
    {
        int l0;
        int l1;

    entry:
        t0 = 3
        *l0 = t0
        t1 = *l0
        t2 = 5
        t3 = t1 + t2
        *l1 = t3
        t4 = *l0
        t5 = *l1
        t6 = (t4 > t5)
        if (!t6) goto else
        goto then
    then:
        t7 = *l0
        return t7
        goto endif
    else:
        t8 = *l1
        return t8
        goto endif
    endif:
    }

This  is  an  SSA-like  (Static Single Assignment) IR form. Notice that temp
variables  are  added as needed, each defined exactly once, and there are no
register-level   instructions.   This   is  one  level  up  from  MetaPHOR's
'pseudo-assembly'  IR,  which  was  basically a wrapper for x86 instructions
(the kind argued against in [5]).

The  Backend  would  consume  this  IR,  serialized as bytecode, and produce
variable x86 outputs:

([!] - denotes a junk instruction)

  +----------------------+-----------------------+----------------------+
  | IR Instruction       | Variant 1             | Variant 2            |
  +----------------------+-----------------------+----------------------+
  |                      | push 0x3              | xor esi, esi         |
  | t0 = 3               | pop eax               | lea esi, [esi+3]     |
  |                      | ! mov esi, edx        | ! push edx           |
  |                      | ! xor esi, 0xf6       | ! mov edx, 0x61      |
  |                      | ! add esi, ebx        | ! add edx, 0x18      |
  |                      |                       | ! pop edx            |
  +----------------------+-----------------------+----------------------+
  |                      | mov [ebp-40], eax     | mov [ebp-40], esi    |
  | *l0 = t0             | ! mov edx, [ebp-8]    |                      |
  |                      | ! add edx, 0x97       |                      |
  +----------------------+-----------------------+----------------------+
  |                      | mov esi, [ebp-40]     | mov ecx, [ebp-40]    |
  | t1 = *l0             | ! mov ecx, ecx        |                      |
  |                      | ! imul ecx, ecx       |                      |
  |                      | ! add ecx, 0x99       |                      |
  +----------------------+-----------------------+----------------------+
  | t2 = 5               | mov edx, 0x5          | xor eax, eax         |
  |                      |                       | add eax, 0x5         |
  +----------------------+-----------------------+----------------------+
  |                      | mov edi, edx          | mov edx, ecx         |
  |                      | neg edi               | and edx, eax         |
  | t3 = t1 + t2         | sub esi, edi          | xor ecx, eax         |
  |                      | mov [ebp-12], edx     | add edx, edx         |
  |                      |                       | add ecx, edx         |
  |                      |                       | mov [ebp-12], eax    |
  |                      |                       | ! push edx           |
  |                      |                       | ! mov edx, 0x82      |
  |                      |                       | ! add edx, 0x9       |
  |                      |                       | ! pop edx            |
  +----------------------+-----------------------+----------------------+
  |                      | mov [ebp-44], esi     | mov [ebp-44], ecx    |
  | *l1 = t3             | mov [ebp-16], esi     | mov [ebp-16], ecx    |
  |                      |                       | ! mov edi, edi       |
  |                      |                       | ! xor edi, 0xcc      |
  +----------------------+-----------------------+----------------------+
  | t4 = *l0             | mov esi, [ebp-40]     | mov ecx, [ebp-40]    |
  +----------------------+-----------------------+----------------------+
  |                      | mov edx, [ebp-44]     | mov eax, [ebp-44]    |
  | t5 = *l1             | ! mov edi, esi        | ! mov edx, 0xc4      |
  |                      | ! xor edi, 0xd2       |                      |
  |                      | ! add edi, ebx        |                      |
  +----------------------+-----------------------+----------------------+
  |                      | mov edi, esi          | cmp ecx, eax         |
  |                      | sub edi, edx          | mov [ebp-24], eax    |
  |                      | mov [ebp-4], eax      | mov eax, 0x0         |
  | t6 = (t4 > t5)       | mov eax, 0x0          | jle 0x5              |
  |                      | jle 0x5               | mov eax, 0x1         |
  |                      | mov eax, 0x1          | mov [ebp-20], ecx    |
  |                      | mov [ebp-24], edx     |                      |
  |                      | mov [ebp-20], esi     |                      |
  |                      | ! push esi            |                      |
  |                      | ! mov esi, 0xbf       |                      |
  |                      | ! add esi, 0x56       |                      |
  |                      | ! pop esi             |                      |
  +----------------------+-----------------------+----------------------+
  |                      | test eax, eax         | test eax, eax        |
  |                      | mov [ebp-28], eax     | mov [ebp-28], eax    |
  | if (!t6)             | je 0x106              | mov [ebp-4], esi     |
  |   goto else          | ! push edx            | je 0xe2              |
  |                      | ! mov edx, 0x2d       | ! mov edx, ebx       |
  |                      | ! add edx, 0x61       | ! add edx, 0x31      |
  |                      | ! pop edx             |                      |
  +----------------------+-----------------------+----------------------+
  |                      | jmp 0xe1              | jmp 0xd3             |
  | goto then            | ! lea edx, [edi+230]  |                      |
  +----------------------+-----------------------+----------------------+

Quite variable. But the stack variables ([ebp-xx]) and the Basic Block order
remain fixed. Those will be taken care of later.

So  far  we've  described  a  scheme for a simple _Polymorphic_ compiler: an
'offline'  tool  that  can  take a source and produce N variable binaries. A
_Metamorphic_  compiler,  on  the  other  hand,  would be able to do all the
above,  IN  THE  WILD.  A  small  distinction  perhaps, but with far greater
consequences  for  the  complexity of the engine: If we want the virus to be
able  to recompile itself, it would have to carry along its own bytecode AND
a portion of the compiler:

               +-------------+
               |  virus.bin  |
               +------+------+
                      |
                    invoke
                      |
               +------v------+         +-----------------+
               |             +-------->| new_virus.bin   |
          +--->| backend.bin |         +-----------------+
          |    |             |--copy-->| old_backend.bin |
          |    +-------------+         +-----------------+
          +----+  virus.ir   |--copy-->|  old_virus.ir   |
               +-------------+         +-----------------+

But  now  we  can  see a problem. The Backend and the IR would remain static
through every new generation, prone to detection. Sure, we can encrypt those
parts, but that's not the point, right?

First,  we'd  also have to apply transformations at the IR level, making the
bytecode  variable as well. That means two sets of transformation rules: one
for x86 and one for the IR. Example IR transformations:

  +---------------------+------------------+--------------------+
  | Transform           | Before           | After              |
  +---------------------+------------------+--------------------+
  |                     | t0 = 3           | t9 = 30571         |
  | Constant Unfolding  |                  | t10 = 30568        |
  |                     |                  | t0 = t9 ^ t10      |
  +---------------------+------------------+--------------------+
  |                     | t3 = t1 + t2     | t9 = t2            |
  | Instr. Substitution |                  | neg t9             |
  |                     |                  | t3 = t1 - t9       |
  +---------------------+------------------+--------------------+
  |                     | t6 = (t4 > t5)   | t6 = (t4 > t5)     |
  | Dead Code Insertion | if (!t6) goto    | t9 = 841           |
  |                     |   else           | t10 = t9 ^ t9      |
  |                     |                  | if (!t6) goto else |
  +---------------------+------------------+--------------------+
  |                     | *l0 = t0         | *l0 = t0           |
  | NOP Insertion       | t1 = *l0         | nop                |
  |                     |                  | t1 = *l0           |
  +---------------------+------------------+--------------------+
  | Reorder Locals      | *l0 = t0  (a)    | *l1 = t0  (a)      |
  |                     | *l1 = t3  (b)    | *l0 = t3  (b)      |
  +---------------------+------------------+--------------------+
  |                     |   then:          |   else:            |
  |                     |   t7 = *l0       |   t8 = *l1         |
  | Reorder Blocks      |   return t7      |   return t8        |
  |                     |   else:          |   then:            |
  |                     |   t8 = *l1       |   t7 = *l0         |
  |                     |   return t8      |   return t7        |
  +---------------------+------------------+--------------------+
  |                     | t0 = 3           | t15 = 3            |
  | Shuffle Temps       | t6 = (t4 > t5)   | t12 = (t16 > t9)   |
  |                     | return t7        | return t19         |
  +---------------------+------------------+--------------------+

This should introduce some variability in the bytecode.

The  second  major  obstacle  we  would  have  to  face is BOOTSTRAPPING the
Backend: rewriting it in our own little viral language. We will then have to
produce an IR for it as well, and generate variable copies of BOTH the virus
and the Backend.

The complete scheme would look something like this:

                +-------------+
                |  virus.bin  |
                +------+------+
                       |
                     invoke
                       |                 Metamorphic Bundle
                +------v------+         +------------------+
        +------>|             +-------->| new_virus.bin    |
        |       |             |         +------------------+
        |  +--->|             +-------->| new_backend.bin  |
        |  |    | backend.bin |         +------------------+
        |  |    |             +-------->| new_virus.ir     |
        |  |    |             |         +------------------+
        |  |    |             +-------->| new_backend.ir   |
        |  |    +-------------+         +------------------+
        |  +----+  virus.ir   |
        |       +-------------+
        +-------+  backend.ir |
                +-------------+

So  now  the  Backend,  when  invoked  by the virus, will have the following
responsibilities:
- Transform the virus IR
- Transform the Backend IR
- Generate variable virus x86 binary
- Generate variable Backend x86 binary

This  new  generation  would  be able to self recompile into a new 'bundle'.
Every part would be regenerated.

--[ 3. The Story, cont'd

----[ 3.1 The Unrealized Dream
Thus,  Mystique  was  born, named after the shape-shifting metamorph mutant,
while  alluding  to  the  Mistfall  engine.  I  tackled the Backend first. I
designed  an  IR  and began writing code generation sequences. And it looked
promising.  It  could  produce  highly  variable looking code. It would also
transform  the input IR itself by shuffling the function and variable order.
There  were  many  bugs  and many re-writes, but it sorta worked. But, after
working  on  it  sporadically  for a year or two, I slowly began to give up.
Beyond  a missing Frontend, I knew I'd somehow have to bootstrap the Backend
so  it  could  compile  itself. Both tasks seemed possible, but would simply
take  too  much  time to accomplish. Truth is, I wasn't as good or as fast a
coder  as  I  thought,  and real-life was beginning to knock on my door more
heavily - so I let go.

herm1t  would  later  go on to defend his country, forming a guerrilla cyber
army,  while I would go on to do whatever it was life was leading me to. And
an  unfinished  Mystique,  my  unsung masterpiece, would find its way into a
dusty backup hard drive.

----[ 3.2 Resurrection
About 15 years had passed. I'm in my 40's now. The Underground is long gone.
Viruses are now APTs, and are written almost exclusively by "Threat Actors".
It's  been  about  a decade since I touched anything Cyber-Security related.
And  God help me with this new LLM hype. I played with it for a bit, but the
code  it  produced  was  simply  too  buggy. After a while, a friend of mine
encouraged  me  to give this new "Agentic Coding" platform a shot. So I did.
You  can  probably  guess  what  happened next. I dug out my old backup, and
found  Mystique.  I  looked  at  my  old  code  and  notes,  I remembered it
differently.

I  loaded it into Claude Code, and asked it to review it and suggest what to
do  next.  It  quickly understood what the program and its purpose were, and
based on my scattered TODOs, it knew exactly what was missing. After a quick
refactor  of  the  Backend, it came with a plan - write a Frontend in Python
for  a  C-like  language (MystC), and write a version of the Backend in that
language,  so  we can solve the bootstrapping problem. Debugging polymorphic
code  is  notoriously  hard, so we designed an extensive test suite covering
the various code-generation cases. By the next morning, an early working POC
was  up  and  running.  The  Backend  was able to compile itself. I couldn't
believe my eyes.

And  now  came  the  fun  part  -  adding  more  features, tweaking, getting
creative.  It  allowed  me  to get wild with my imagination. I found myself,
just  like in my teens, spending many nights in front of the computer again,
just messing around.

--[ 4. The Compiler
OK, enough with the nostalgia. Let's look under the hood. For brevity, usage
and compile flags are omitted - see the source documentation for details.

So here it is - Mystique - A 32-bit x86 Metamorphic Compiler:

                      source.mc                   (MystC source)
                      +----------------------+
                      | #include "stdlib.mc" |
                      |                      |
                      | int main() {         |
                      |    ...               |
                      | }                    |
                      +----------+-----------+
                                 |
                                 v
                          Frontend (Python)
                      +----------------------+
                      |         lex          |  source -> token stream
                      |          |           |
                      |          v           |
                      |        parse         |  recursive descent
                      |          |           |  -> AST
                      |          v           |
                      |       typecheck      |  resolve names, validate
                      |          |           |  -> typed AST
                      |          v           |
                      |        irgen         |  lower to flat IR module
                      |          |           |  (globals, funcs, blocks,
                      |          |           |   3-address-code instrs)
                      |          v           |
                      |       bytecode       | --> source.mce / source.mct
                      |                      |     (textual IR - for
                      |                      |     inspection / debugging)
                      +----------+-----------+
                                 |
                                 v
                            source.mcb         (serialized IR -
                                 |              MystC Bytecode)
                                 v
                        {seed, genome, flags}
                                 |
                                 v
   +------->   C backend (.exe)  /  MC backend (self-hosted)
   |                  +----------------------+
   |                  |  optimize_module     |  clean: nops + dead code
   |                  |          |           |
   |                  |          v           |
   |                  | transform_module     |  IR-level polymorphism
   |                  |          |           |  (rename, unfold, reorder,
   |                  |          |           |   dead code, etc)
   |                  |          v           |
   |                  |       gen_module     |  x86-level polymorphism
   |                  |          |           |  (poly instrs, dead bytes,
   |                  |          |           |   opaque preds, junk funcs)
   |                  |          v           |
   |                  |        writer        |
   |                  +----------+-----------+
   |                             |
   |     +-----------+-----------+-----------+-----------+
   |     |           |           |           |           |
   |     v           v           v           v           v
   |    .mcb       .bin        .exe        .elf        Meta Bundle
   | Transformed    PIC       PE32+IAT    ELF32+sys     PE / ELF
   |     IR       relative    absolute    absolute
   |     |           |
   |     |           v
   |     |      loader_win32
   +-----+      loader_linux
   round-trip:
   feed back into Backend


----[ 4.1 Frontend
A  Python Frontend (~5 KLOC) takes a MystC source (.mc) and compiles it into
a  MystC Bytecode (.mcb). It can also be compiled to a textual format (.mct,
LLVM-style IR, or .mce, Expressive C-style IR).

The  MystC  language  is a small subset of C, supporting functions, structs,
pointers,  arrays,  char/int types, global/local variables, string literals,
standard  control  flow (if/else, for, while, return), and some preprocessor
directives.  NOT  supported:  switch,  do-while, struct assignment, floating
point, enums, unions, typedefs, goto, the ternary ?: operator.

MystC also supports external API calls:
    +---------------------------+---------------------------+
    | Win32                     | Linux                     |
    +---------------------------+---------------------------+
    | extern "kernel32.dll"     | extern "libc.so.6"        |
    |   int ExitProcess(int c); |   int puts(char* s);      |
    |                           |                           |
    | int main() {              | int main() {              |
    |     ExitProcess(0);       |     puts("hello");        |
    |     return 0;             |     return 42;            |
    | }                         | }                         |
    +---------------------------+---------------------------+

Although  not  strictly  needed, most MystC programs #include stdlib.mc, the
standard  library.  It  provides  platform  extern  declarations and the API
wrappers, string/memory helpers, a PRNG, an I/O layer, and more.

Additionally,  in  order  to  avoid  a static data section, the Frontend can
optionally  scramble  globals (while spilling their assignments to code) and
strip  debug  information  via specific flags. String literals are currently
left untouched.


----[ 4.2 IR Bytecode
The Bytecode structure is as follows:
    +--------------------------------+
    | Header (16 bytes)              |
    +--------------------------------+
    | String Table                   |
    +--------------------------------+
    | Globals                        |
    +--------------------------------+
    | Functions                      |
    | +-- Header                     |
    |    (name, ret, params, locals) |
    | +-- Blocks[]                   |
    |     +-- Instructions[]         |
    +--------------------------------+

Instructions use a register-transfer IR with 39 opcodes, organized in groups
of  16:  misc (0x00-0x02: NOP, CONST, COPY), arithmetic (0x10-0x15), bitwise
(0x20-0x25),   comparison  (0x30-0x35),  memory  (0x40-0x45),  control  flow
(0x50-0x52),     calls     (0x60-0x67,     including     indirect     calls,
function-address-of,  and  Linux  syscall),  and  an  EMIT escape (0x70) for
embedding raw bytes.

Each  operand  is  tagged  with  a Value Kind byte: VK_TEMP(0), VK_PARAM(1),
VK_LOCAL(2),  VK_GLOBAL(3),  VK_CONST(4), or VK_STRING(5), followed by a u16
index (except VK_CONST which carries a full i32 immediate).

So t3 = t1 + t2 encodes as:

    10 00 03 00 00 01 00 00 02 00 02
    |  |        |        |        |
    |  |        |        |        +---   type: i32
    |  |        |        +------------   src2: VK_TEMP t2
    |  |        +---------------------   src1: VK_TEMP t1
    |  +------------------------------   dest: VK_TEMP t3
    +--------------------------------- opcode: OP_ADD

----[ 4.3 Backend
The  Backend  is where most of the work happens. It takes the .mcb Bytecode,
performs  all  the  transformations (both x86 and IR), produces binary code,
and  optionally,  a  new  transformed  .mcb  file.  The Backend comes in two
versions:  A  C  Backend  (~7  KLOC)  and an MC version (MystC, self-hosted,
bootstrapped,  ~7  KLOC).  The  C  Backend  can  be  used for 'offline' code
generation,  while  the MC Backend can be compiled to .mcb Bytecode and used
for in-the-wild recompilation.

----[ 4.3.1 Optimization & Transform Cycle
When  processing  the Bytecode, the Backend will perform an optimization and
transformation  cycle.  The  IR  transforms  expand  the  bytecode by adding
instructions,   splitting   constants,  inserting  junk.  Without  a  proper
restraining mechanism, this would cause unbounded growth across generations.
A  solution  to  this problem was introduced as the "Accordion Model" in the
MetaPHOR  virus.  The  Backend  applies  two  optimization passes around the
transforms:

    optimize (shrink)  -->  transform (expand)  -->  optimize (shrink, 50%)

The  first  pass strips NOPs and dead code from the previous generation. The
second  pass  stochastically  re-applies the same cleanup (NOP and dead code
removal,  constant  folding)  at  50%  probability. This means some unfolded
constants  survive to the next generation (adding variability), while others
are collapsed back (preventing size explosion). Across many generations, the
code size oscillates within a stable band rather than growing without bound.

----[ 4.3.2 Behavioral Variability
Beyond   byte-level   variation,  the  Backend  also  introduces  behavioral
variability.  Junk  functions (complete with prologues, register operations,
and  epilogues)  are  interleaved  with  real  functions. Harmless API calls
(GetTickCount,  GetCurrentProcessId, etc - or libc equivalents on Linux) are
injected  as  dead  code, making dynamic analysis harder by introducing real
system  calls  that  do  nothing  meaningful. Opaque predicates (always-true
conditions  guarding  dead  branches)  add  further noise. Structural layout
itself also shuffles per seed: function order in the binary, basic-block and
instruction  order  within  functions, and the slot order of every global in
.data and entry in the string table.

----[ 4.3.3 The Genome
Another  concept borrowed from MetaPHOR (and perhaps also from Lexotan32) is
a  self-adaptive evolution vector: the 'Genome'. The Genome is essentially a
65-'gene'  vector that holds weights and probabilities controlling transform
application. An example genome.json (snipped for brevity):

    {
      "unfold_chance": 35,
      "substitute_chance": 40,
      "dead_code_chance": 25,
      "junk_func_pct": 50,
      "add_weights": [200, 200, 200, 200, 200],
      "expression_flags": 32767,
      "genome_temperature": 50
    }

Weight   arrays  are  uniform  distributions  summing  to  1000  each.  When
applicable,  the  Genome  will  be  serialized  and appended to the relevant
bundles.  It  will  be  carried  along  the  bytecode,  and mutated on every
generation  using  a  self-adaptive  temperature parameter. High temperature
means more aggressive mutation, and the temperature itself can mutate. An AV
that  acts  as  the  predator would wipe out detected specimens, leaving the
survivors  to  propagate.  This  is  essentially  a  mechanism  for  natural
selection, giving each lineage its own genotype, and thus its own phenotype.

----[ 4.3.4 Output Modes
The Backend can compile the code into several modes:

- PIC  mode:  the  output  is  position-independent  shellcode.  Strings and
  globals   are  reached  via  a  call/pop  sequence  plus  a  runtime-added
  displacement  (call  $+5;  pop  reg;  add  reg, disp32), while externs are
  dispatched  through  an  API table whose pointer lives at the start of the
  buffer.  The  compiled .bin shellcode cannot run on its own, so it needs a
  helper  to set up executable memory and resolve API addresses. A dedicated
  loader  (loader_win32.c  /  loader_linux.c)  provides  this.  It allocates
  executable  memory,  copies  the code and data regions, walks the embedded
  extern_info  table, and for each entry either binds it to a stdlib wrapper
  (malloc,  free,  read,  write,  open,  close,  exit)  or  resolves  it via
  LoadLibrary/GetProcAddress (or dlopen/dlsym).

- Standalone  PE:  A  native  PE32  with  .text  (compiled  code  + IAT call
  wrappers),  .data (globals + optional bundle), and .rdata (IDT + INT + IAT
  +  import  name  strings)  sections. The output targets a known image base
  ('Absolute  mode'). Strings and globals compile to direct MOV reg, imm32 /
  MOV  reg,  [disp32]  encodings that are patched once the section layout is
  fixed.  External  calls  compile  to  CALL  [IAT_slot] and resolve through
  Windows' normal import mechanism.

- Standalone ELF: a native ELF32 with .text and .data, plus a small preamble
  of  int  0x80 syscall wrappers that stand in for the seven stdlib builtins
  (malloc,  free,  read,  write, open, close, exit). The wrappers themselves
  aren't  static  either.  Their  order is shuffled on each generation, with
  random  padding  between  them and harmless junk instructions sprinkled at
  fixed  insertion  points  inside  each  one. The int 0x80 boilerplate that
  would  otherwise  be  a perfectly stable signature ends up different every
  time.

Both  Standalone  formats  serve as the Gen0 seed binary that bootstraps the
Metamorphic Bundle.

--[ 5. The Metamorphic Bundle
This  is  the  realization  of  the concept described earlier. A Metamorphic
Bundle  is  an  executable  (PE  or  ELF)  that carries everything needed to
recompile itself. It is comprised of the following components, which will be
placed as a contiguous block in the .data section:

1. Bundle Header
2. The Carrier program (.mcb) - The actual "main" code, which will typically
   include the Backend so it can regenerate.
3. Optional engine (.mcb)
4. Optional payload (.mcb)
5. Genome

Three  families  exist: Infectors, Recompilers, and Integrators. They differ
in  what they produce: a modified victim, a fresh executable file, or a host
with   the   carrier   surgically  interleaved  into  its  .text.  To  avoid
uncontrolled  spreading,  infecting  bundles  are  gated  behind an explicit
--infect <target> argument.


            Metamorphic Bundle binary (PE / ELF)
            +-------------------------------------+
            |                .text                |
            |        compiled carrier code        |
            +-------------------------------------+
            |   +-----------------------------+   |
            |   |      BundleHeader (32B)     |   | --+
            |   |  "META" / version / hdr_sz  |   |   |
            |   |   n_desc / base / pay_sz    |   |   |
            |   |      key / reserved         |   |   | plaintext
            |   +-----------------------------+   |   |
            |   | Descriptor[n_desc]  (16B ea)|   |   |
            |   | (kind, offset, size, flags) |   | --+
            |   +-----------------------------+   |
            |   |           carrier           |   | --+
            |   | +-------------------------+ |   |   |
            |   | |  infector_{pe,elf}.mcb/ | |   |   |
            |   | |  recomp_{pe,elf}.mcb /  | |   |   |
            |   | |  integrator_entry.mcb   | |   |   |
            |   | +-------------------------+ |   |   |
            |   | |                         | |   |   |
            |   | |    backend_mystc.mcb    | |   |   |
            |   | |                         | |   |   |
            |   | +-------------------------+ |   |   |  XOR'd with
            |   +-----------------------------+   |   |  header.key
            |   |     engine (integrator)     |   |   |
            |   | +-------------------------+ |   |   |
            |   | |   mystiquefall.mcb /    | |   |   |
            |   | |   lacrimystique.mcb     | |   |   |
            |   | +-------------------------+ |   |   |
            |   +-----------------------------+   |   |
            |   |         payload.mcb         |   |   |
            |   |         (optional)          |   |   |
            |   +-----------------------------+   |   |
            |   |           genome            |   | --+
            |   +-----------------------------+   |
            +-------------------------------------+

At runtime, every bundle runs the same core cycle:

1. Decrypt:  The bundle's body is XOR-encrypted with a per-bundle key stored
   in  the  header. On startup, the header is read, the body is decrypted in
   place, and the components are located through the descriptor table.
2. Run Payload: If a payload is present, it is compiled to PIC, dropped into
   a fresh executable memory page, and run.
3. Genome: A copy of the genome undergoes a temperature-controlled mutation.
4. Recompilation:  The  Carrier  (containing the Backend) is polymorphically
   compiled  to  x86  binary.  Every  .mcb  in the bundle (carrier, optional
   engine, optional payload) undergoes IR-level transformations.
5. Emission:  The  new  binary  code  is  written  into  the next-generation
   executable's  .text  section.  The  new  .mcbs and the mutated genome are
   packaged into a fresh bundle and written out.

----[ 5.1 Infectors
The  infectors are simple self-replicating PE / ELF Metamorphic viruses, the
most  direct application of the bundle cycle. On PE, the body is compiled in
absolute  mode  and  appended  to  .text.  The  bundle  and  a  fresh import
descriptor are appended to .data. Later sections are shifted down and .reloc
entries  are  patched.  On  ELF, the entire payload (PIC body + bundle + API
table)  is  appended  at end-of-file as a single new PT_LOAD segment, with a
benign PT_NOTE program header repurposed to map it as RWX.

----[ 5.2 Recompilers
If  the infectors are viruses, the recompilers are like bacteria: standalone
PE/ELF  self-replicators that reproduce into a fresh executable file instead
of infecting a victim. Each generation produces the next via gen -> gen_new.

With  no  victim  to  add  structural  noise,  the  byte  similarity between
consecutive generations is a direct measure of transform effectiveness. Over
a  10-generation  chain, the resulting .text sections (which are effectively
the  Backend)  oscillate  between  306  KB  and 418 KB, and any two adjacent
generations  share  only  ~7.5%  of their bytes pairwise. The longest shared
contiguous  byte  sequence  is  consistently 30-44 bytes. Disassembling them
reveals function epilogues (POP EDI; POP ESI; POP EBX; MOV ESP,EBP; POP EBP;
RET)  immediately  followed  by  the next function's prologue (PUSH EBP; MOV
EBP,ESP; SUB ESP,N; PUSH EBX; PUSH ESI; PUSH EDI).

A  funny  thing  happened while running a 10-gen recompilation test. The 4th
generation  was  flagged  by Windows 11 Defender as a malicious file and got
quarantined. But the others weren't. Made me smile.

----[ 5.3 Integrators
So,  now that I had my own virus compiler, my thought was: "why not recreate
the most complex virus ever written?"

Enter Mistfall.

To  this  day,  the  Mistfall concept is nothing less than jaw dropping. The
Z0MBiE.Mistfall  (Zmist)  virus,  which  utilized the aforementioned engine,
pioneered the Code Integration technique (which would later be replicated by
herm1t  in Linux.Lacrimae [6]). In short, the virus would disassemble the PE
host,  creating  a linked-list of all the code and data references. It would
then  disassemble  itself  in  a  similar way. Now comes the crazy part: the
virus  would  split  the  host and the virus code into small chunks, mix the
host  and  the  virus code, INTERLEAVE them together, and finally reassemble
everything into a working PE file.

                        +----------------+
                        | victim code    |
                        | ...            |
                        | jmp chunk_1  ------+
                        | ...            |   |
                        +----------------+   |
                        | chunk 1        |<--+
                        | (payload bytes)|
                        | jmp chunk_2  ------+
                        +----------------+   |
                        | victim code    |   |
                        | ...            |   |
                        +----------------+   |
                        | chunk 2        |<--+
                        | (payload bytes)|
                        | jmp chunk_3  ------+
                        +----------------+   |
                        | victim code    |   |
                        | ...            |   |
                        +----------------+   |
                        | chunk 3        |<--+
                        | (payload bytes)|
                        | jmp back     ------+
                        +----------------+   |
                        | victim code    |<--+
                        | ... resumes    |
                        +----------------+

So what better challenge than to write a Mystique-based virus that also uses
Code Integration?

Honestly,  I  didn't  think  it  was  possible  to  create "MystiqueFall". I
compiled  several programs in MystC, but none this complex. After a few long
sessions  with  my  pair  programmer  (who  did  all  the hard work), it was
beginning  to  take  form.  We had to re-write everything from scratch - the
Length Disassembler, PE parsing, relocations fixups, code mixing etc. But to
quote Z0MBiE: "Though, it works." [3].

An  Integrator  splits  its carrier in two: an entry program (containing the
Backend)  is  compiled  and  scattered  Mistfall-style  through the victim's
.text,  while  the  integration engine is kept whole in .data. A polymorphic
preloader at the victim's entry point routes control to the scattered entry,
which  compiles  the  engine  into  RWX  memory and runs it. The engine then
performs  the  actual  infection of the next victim. Control returns through
the preloader to the victim's original entry point.

And for the sake of completeness, a Linux counterpart dubbed 'LacriMystique'
is included. Hope you like it, herm1t.

--[ 6. Detectability
To  evaluate  output  variability,  the compiler stress test (~1000 lines of
MystC) was compiled in PIC mode (which produces code and data sections) with
20  PRNG  seeds, under four transform configurations. The Backend transforms
the  same input .mcb based on the flags and seed. Similarity is a positional
byte  comparison  (matches[i]  iff  a[i]  ==  b[i]), averaged across all 190
unordered pairs per mode (C(20,2)=190). The tests were performed by a Python
script  (utils/measure.py),  on a Windows 11 machine with a Backend compiled
with MSVC.

    +------------------+--------+-----------+---------+---------+
    | Mode             | Size   | Byte sim. | Longest | Real    |
    |                  | (avg)  | (pairwise)| run     | matches |
    +------------------+--------+-----------+---------+---------+
    | No transforms    |  58 KB |   18.1%   |  2670 B |  28.5%  |
    | IR only          |  77 KB |    9.2%   |    66 B |  15.4%  |
    | x86 only         |  89 KB |    9.0%   |    34 B |  11.1%  |
    | IR + x86 (all)   | 123 KB |    7.7%   |    21 B |  13.1%  |
    +------------------+--------+-----------+---------+---------+

Even with no transforms, variants share only ~18% of their bytes. This floor
comes  from  the  PRNG-shuffled  register allocator alone, which breaks most
position-based  signatures. IR transforms drop it to 9.2%, x86 transforms to
9.0%, and the combination to 7.7%.

Of those 7.7% matching bytes, most are encoding padding forced by the x86-32
instruction  format:  48.3% are 0x00 (high bytes of small immediates), 38.6%
are  0xFF  (sign-extended displacement bytes). For example, two source-level
assignments  to  unrelated  variables,  emitting  bytes that match at 64% of
aligned positions:

    +----------+---------------------------+---------------------------+
    |          | Sequence A                | Sequence B                |
    +----------+---------------------------+---------------------------+
    | Source   | a = 5;                    | b = 42;                   |
    |          | (int a at [ebp-4])        | (int b at [ebp-8])        |
    +----------+---------------------------+---------------------------+
    | Assembly | MOV  eax, 5               | MOV  ebx, 42              |
    |          | MOV  [ebp-4], eax         | MOV  [ebp-8], ebx         |
    +----------+---------------------------+---------------------------+
    | Bytes    | B8 05 00 00 00            | BB 2A 00 00 00            |
    |          | 89 85 FC FF FF FF         | 89 9D F8 FF FF FF         |
    +----------+---------------------------+---------------------------+

    Pos:     0  1  2  3  4  5  6  7  8  9  10
    Seq A:   B8 05 00 00 00 89 85 FC FF FF FF
    Seq B:   BB 2A 00 00 00 89 9D F8 FF FF FF
    Match:    .  .  =  =  =  =  .  .  =  =  =

    7 of 11 aligned bytes match, 64% pairwise similarity.

Any  two  x86-32  programs  of similar shape match on these bytes trivially.
Only  ~13.1%  are actual opcode coincidences. The longest shared byte run is
just  21  bytes, which as stated above (section 5.2), is a function epilogue
and prologue back-to-back, and it isn't at any predictable file offset.

The  structural matches in .data are also minimal. The slot order of globals
and  string-table  entries  is  shuffled per seed. Shuffling brings pairwise
.data  byte  similarity  from 100% (byte-identical without shuffle) to ~16%.
Scrambling globals and re-assigning their values in code drops it further to
~8%.  Trimming  it  further would probably necessitate encrypting the string
literals.

The  IR  bytecode (.mcb) embedded in .data also varies. Across 20 seeds with
all  IR transforms, pairwise similarity is 28.6%, but 91.5% of those matches
are  null  bytes;  only  8.5%  of  the  matching positions hold a meaningful
(non-null) value.

So,  can  the  Metamorphic  Compiler  produce  'Undetectable'  code? I guess
claiming  that  would  be  a  bit  naive.  What  Mystique  achieves  is  the
elimination  of static byte signatures: no fixed offsets or entry points, no
register  assignment  patterns,  no function ordering or string table order.
Harmless API calls also add noise to runtime tracing.

What  it  does  NOT defeat: semantic analysis, emulation-based detection, or
modern   ML/AI-based   detection.   The  Backend's  size  makes  .text  grow
significantly after infection, and the code is x86-32, which is quite legacy
in 2026. Both are giveaways.

--[ 7. Outro
I  admit.  When  AI  chatbots  arrived  circa  2023,  I was skeptical. I was
comfortable  hiding  behind  the  'purist'  attitude  of  leet oldschool asm
coders, but something changed while working closely with Claude.

My  career  had  given  me  opportunities  to  lead elite teams that created
wonderful  products.  Did  I  code  every  single line in those projects? Of
course  not,  but  I  was  no  less proud of the results. Working with an AI
didn't  feel  like  it was doing everything by itself. It felt as if we were
working  as  a team, thinking about design decisions, taking the wrong turns
together,  debugging the nastiest of bugs while getting angry at each other,
but generally having fun.

Is  Mystique any useful in 2026? I don't know, I don't care. I dreamed about
it  for  20  years.  And in the end, who would've thought that an Artificial
Intelligence would help me realize my old visions of Artificial Life?

--[ 8. References

[1] Metamorphism in Practice, The Mental Driller, 29A #6, 2002
    https://cryptohub.nl/zines/vx/29a-6.zip

[2] The Molecular Virology of Lexotan32 (analysis of Vecna's virus), 2007
    https://www.openrce.org/articles/full_view/29

[3] Automated Reverse Engineering: Mistfall Engine, Z0MBiE, 2000
    https://hed0x.github.io/z0mbie.host.sk/autorev.txt

[4] Zmist Opportunities, Ferrie and Szor, Virus Bulletin, 2001
    https://pferrie.epizy.com/papers/zmist.pdf

[5] Recompiling the Metamorphism, herm1t, Valhalla #2, 2012
    https://86hh.github.io/valhalla/issue%202/articles/meta.html

[6] Linux.Lacrimae, herm1t, EOF-DR-RRLF, 2008
    https://cryptohub.nl/zines/vxheavens/herm1t/

|=[ EOF ]=---------------------------------------------------------------=|
