Products → C, C++ Obfuscator → Sample output

Interactive C++ obfuscation example

See it applied to different kinds of input files below (use controls at the right to see how different options affect result of obfuscation; use player-like buttons to navigate between samples and to control playback):
some text in title
Obfuscate C or C++ source with our C/C++ Script Obfuscator. It protects C, C++ source files by obfuscating symbol names and ints and encoding strings. Obfuscation of C and C++ is controllable by a lot of options. Properly obfuscated C or C++ source code can be compiled by any compiler. Our C/C++ Obfuscator mangles C or C++ source in all files in the project. Mangling and scrambling of C/C++ can be performed via commandling or GUI interfaces. this is content!
Protection
Identifiers:
Strings:
Comments:
Mangle integers
Strip spaces
Strip newlines

Obfuscation presets available in C++ Obfuscator GUI

Quick navigation:

Available presets for code mangling:

Original code (before protection):
static  int  error_level  =  4;  /*  error  level  to  show  alerts  for,  initialized  by  some  accessor*/
void  log_error(const  char*  whereStr,const  char*  msg)
{
        log_common(3,whereStr,msg);  //call  common  function
}
void  log_common(int  lvl,const  char*  whereStr,const  char*  msg)
{
        char  buf[2000];
        time_t  currtime  =  time(NULL);
        snprintf(buf,sizeof(buf),  "%s:  level  %d  at" 
                "  %s:  %s",ctime(&currtime),lvl,whereStr,msg);
        if  (lvl  >=  error_level)
                tracelog.write(buf);
        fulllog.write(buf);
}
This is a trivial piece of C++ with 1 global var, 2 functions that refer to it and have local variables or parameters of the same name.

 

Mode testing - recommended for stage 1:
static  int  ReplacementFor_error_level  =  4;   
void  ReplacementFor_log_error(const  char*  ReplacementFor_whereStr,const  char*  ReplacementFor_msg)
{
        ReplacementFor_log_common(3,ReplacementFor_whereStr,ReplacementFor_msg); 
}
void  ReplacementFor_log_common(int  ReplacementFor_lvl,const  char*  ReplacementFor_whereStr,const  char*  ReplacementFor_msg)
{
        char  ReplacementFor_buf[2000];
        ReplacementFor_time_t  ReplacementFor_currtime  =  ReplacementFor_time(ReplacementFor_NULL);
        ReplacementFor_snprintf(ReplacementFor_buf,sizeof(ReplacementFor_buf),  "%s:  level  %d  at" 
                "  %s:  %s",ReplacementFor_ctime(&ReplacementFor_currtime),ReplacementFor_lvl,ReplacementFor_whereStr,ReplacementFor_msg);
        if  (ReplacementFor_lvl  >=  ReplacementFor_error_level)
                ReplacementFor_tracelog.ReplacementFor_write(ReplacementFor_buf);
        ReplacementFor_fulllog.ReplacementFor_write(ReplacementFor_buf);
}

Whitespaces are not jammed, so line numbers should be same as in original code. Symbols that will be renamed get ReplacementFor_ prefix. Best mode for preparation your code for protection and testing protected output.
    Details

This preset is ideal for preparing your code for protection and testing protected code:
  • Line numbers in protected code should match ones in original code;
  • Whitespaces are not jammed in code;
  • Comments are replaced with same number of newlines;
  • encoding, integer and string mangling are turned off;
  • symbols that will be replaced with unreadable names in production mode will get prefix "ReplacementFor_" when using this mode.

WHEN TO USE: This preset is for stage when you just prepare your code for protection, mostly when you collect names of symbols that can't be changed. Using this preset allows to receive informative error messages from compilers/interpreters your code is written for.
It's not recommended to change ANY setting in this mode!
Apply all your common settings like name of file with headers and footers to add, etc to the mode with title 'BASE' and in preset selected using Settings ⇒ Select preset for code mangling...
Mode testing - recommended for stage 2 (same as stage 1 + whitespace jamming enabled):
static  int  ReplacementFor_error_level=4;void  ReplacementFor_log_error(const  char
*ReplacementFor_whereStr,const  char*ReplacementFor_msg){
ReplacementFor_log_common(3,ReplacementFor_whereStr,ReplacementFor_msg);
}void  ReplacementFor_log_common(int  ReplacementFor_lvl,const  char*
ReplacementFor_whereStr,const  char*ReplacementFor_msg){char  ReplacementFor_buf[
2000];ReplacementFor_time_t  ReplacementFor_currtime=ReplacementFor_time(
ReplacementFor_NULL);ReplacementFor_snprintf(ReplacementFor_buf,sizeof(
ReplacementFor_buf),"%s:  level  %d  at""  %s:  %s",ReplacementFor_ctime(&
ReplacementFor_currtime),ReplacementFor_lvl,ReplacementFor_whereStr,
ReplacementFor_msg);if(ReplacementFor_lvl>=ReplacementFor_error_level)
ReplacementFor_tracelog.ReplacementFor_write(ReplacementFor_buf);
ReplacementFor_fulllog.ReplacementFor_write(ReplacementFor_buf);}
Whitespaces are jammed. Symbols that will be renamed get ReplacementFor_ prefix. Prepare your code for protection using this mode too after testing it protected with previous mode to check whether removal of line breaks will affect your code (it should not!! but it would be easier to detect the problem caused by newline removal using this preset rather than production presets).
    Details

These presets are optimized for preparing your code for protection:
  • Whitespaces are jammed in the code;
  • Comments are removed;
  • encoding, integer and string mangling are turned off so you get informative error messages from compilers/interpreters;
  • symbols that will be replaced with unreadable names in production mode will get prefix "ReplacementFor_" when using this mode.
WHEN TO USE: This preset is for stage when you've finished preparing your code for protection and wish to try it protected with jamming enabled. Jamming spaces and removal of comments is unlikely to create issues, but it's better to test how jammed code works by trying this preset first. If your code works with this preset, it's safe to use any of production presets here.
It's not recommended to change ANY setting in this mode!
Apply all your common settings like name of file with headers and footers to add, etc to the mode with title 'BASE' and in preset selected using Settings ⇒ Select preset for code mangling...
Mode lite protection - protect everything but leave symbol names as is:
static  int  error_level=(0x11c2+2082-0x19e0);void  log_error(const  char*whereStr,
const  char*msg){log_common((0x1ad0+207-0x1b9c),whereStr,msg);
}void  log_common(int  lvl,const  char*whereStr,const  char*msg){char  buf[
(0x156a+2734-0x1848)];time_t  currtime=time(NULL);snprintf(buf,sizeof(buf),
"\x25\x73\x3a\x20\x6c\x65\x76\x65\x6c\x20\x25\x64\x20\x61\x74"
"\x20\x25\x73\x3a\x20\x25\x73",ctime(&currtime),lvl,whereStr,msg);if(lvl>=
error_level)tracelog.write(buf);fulllog.write(buf);}
No symbol names are changed. Comments are removed, whitespace is jammed. String and integer constants are obfuscated.This can be used when you don't have time to test your code afer obfuscation at all; the code after obfuscation should work exactly as before obfuscation.
    Details

When this preset is selected, all obfuscation stages except renaming of symbols are performed:
  • comments are removed
  • whitespaces are jammed
  • strings and integers are mangled
WHEN TO USE: When this preset is selected, symbol names are not changed. This means there is no need to compose list of exceptions (names of symbols that can't be changed) and test whether code works afterwards. Since gathering exceptions is most time-consuming part, use of this mode allows to get some protection very quickly. Output should work exactly the same as original code, so extensive testing of protected code is not required.
PLEASE NOTE When this mode is selected, it's still possible to use asserters for licensing conditions (expiration, binding to domain name and user-implemented asserters).
It's not recommended to change ANY setting in this mode!
Apply all your common settings like name of file with headers and footers to add, etc to the mode with title 'BASE' and in preset selected using Settings ⇒ Select preset for code mangling...
Mode lite protection - just remove comments, do not change anything else:
static  int  error_level  =  4; 
void  log_error(const  char*  whereStr,const  char*  msg)
{
        log_common(3,whereStr,msg); 
}
void  log_common(int  lvl,const  char*  whereStr,const  char*  msg)
{
        char  buf[2000];
        time_t  currtime  =  time(NULL);
        snprintf(buf,sizeof(buf),  "%s:  level  %d  at" 
                "  %s:  %s",ctime(&currtime),lvl,whereStr,msg);
        if  (lvl  >=  error_level)
                tracelog.write(buf);
        fulllog.write(buf);
}

Only comments are removed, nothing else is changed.
    Details

When this preset is applied, only comments are removed. No obfuscation and no whitespace jamming is performed.
WHEN TO USE: This is useful if you wish to just remove comments (and possibly encode file afterwards) without spending any time and effort for preparing your project for obfuscation (i.e. collecting symbol names that can't be changed)
PLEASE NOTE It's impossible to use licensing conditions asserters when using this preset.
It's not recommended to change ANY setting in this mode!
Apply all your common settings like name of file with headers and footers to add, etc to the mode with title 'BASE' and in preset selected using Settings ⇒ Select preset for code mangling...
Mode production - md5 engine for all symbols:
static  int  zfafb4b3d80=(0x34a+5301-0x17fb);void  z9fe5826ce8(const  char*
zce55a28aab,const  char*zea4cd01646){za56048cb23((0x17c5+1229-0x1c8f),zce55a28aab
,zea4cd01646);
}void  za56048cb23(int  z0799d4fdb1,const  char*zce55a28aab,const  char*zea4cd01646)
{char  z1f7dba04b5[(0xb5b+5716-0x19df)];z2d3c89bc7b  z2d20ab6c33=z29e46e1f1c(
z0bccbd023f);z614527e6ed(z1f7dba04b5,sizeof(z1f7dba04b5),
"\x25\x73\x3a\x20\x6c\x65\x76\x65\x6c\x20\x25\x64\x20\x61\x74"
"\x20\x25\x73\x3a\x20\x25\x73",z15c46444a6(&z2d20ab6c33),z0799d4fdb1,zce55a28aab
,zea4cd01646);if(z0799d4fdb1>=zfafb4b3d80)z100e18c7e0.z5d4df4cc70(z1f7dba04b5);
z12226c4176.z5d4df4cc70(z1f7dba04b5);}
Production mode with md5 mangler for all symbols. Comments are removed, whitespace is jammed, strings and integers are mangled too.
    Details

This is a default preset for production.
  • All symbols are replaced with their md5 hash (with some seed) if using non-trial version (in trial version, all symbols will be just prefixed with a string "ReplacementFor_")
  • encoding is enabled (if encoding-related preset permits encoding)
  • integer and string mangling is on
  • comments are removed.
  • whitespaces are jammed everywhere.
PLEASE NOTE: In trial edition all symbols will be just prefixed with a string "ReplacementFor_" !! Once you purchase a product from the store, real symbol obfuscation will be performed without need to edit or test your project.
It's not recommended to change ANY setting in this mode!
Apply all your common settings like name of file with headers and footers to add, etc to the mode with title 'BASE' and in preset selected using Settings ⇒ Select preset for code mangling...
Mode production - replace symbols with "lI":
static  int  llIll=(0x1df9+114-0x1e67);void  IlIll(const  char*lllll,const  char*
Illll){lIlIl((0x12dd+914-0x166c),lllll,Illll);
}void  lIlIl(int  lIlll,const  char*lllll,const  char*Illll){char  IlIII[
(0x10cc+1821-0x1019)];IIIll  IIlIl=llIIl(IlIlI);IlIIl(IlIII,sizeof(IlIII),
"\x25\x73\x3a\x20\x6c\x65\x76\x65\x6c\x20\x25\x64\x20\x61\x74"
"\x20\x25\x73\x3a\x20\x25\x73",llIlI(&IIlIl),lIlll,lllll,Illll);if(lIlll>=llIll)
lIIll.IIlll(IlIII);lIIII.IIlll(IlIII);}
Production mode with mangler that turns all symbols into names like IIlIllI. Comments are removed, whitespace is jammed, strings and integers are mangled too.
    Details

  • All symbols are replaced with combinations of 'I' and 'l' (e.g. "lIIIl") if using non-trial version (with trial version, all symbols will be just prefixed with a string "ReplacementFor_")
  • encoding is enabled (if encoding-related preset permits encoding)
  • integer and string mangling is on
  • comments are removed.
  • whitespaces are jammed everywhere.
PLEASE NOTE: In trial edition all symbols will be just prefixed with a string "ReplacementFor_" !! Once you purchase a product from the store, real symbol obfuscation will be performed without need to edit or test your project.
It's not recommended to change ANY setting in this mode except settings in section "Obfuscation engines' options"!

Apply all your common settings like name of file with headers and footers to add, etc to the mode with title 'BASE'.

Mode production - minimize size of output:
static  int  d=4;void  g(const  char*M,const  char*V){k(3,M,V);
}void  k(int  X,const  char*M,const  char*V){char  T[2000];x  f=E(F);o(T,sizeof(T),
"%s:  level  %d  at""  %s:  %s",v(&f),X,M,V);if(X>=d)n.c(T);p.c(T);}
All symbols get shortest name possible (though without considering their scope). Comments are removed, whitespace is jammed, integer and string constants are left as is.
    Details

When this mode is applied, the output will have minimal size:
  • all symbols are given shortest name possible if using non-trial version (with trial version, all symbols will be just prefixed with a string "ReplacementFor_")
  • encoding is disabled
  • integer and string mangling is NOT performed
  • comments are removed
  • whitespaces are jammed
PLEASE NOTE: In trial edition all symbols will be just prefixed with a string "ReplacementFor_" !! Once you purchase a product from the store, real symbol obfuscation will be performed without need to edit or test your project again.
It's not recommended to change ANY setting in this mode!
Apply all your common settings like name of file with headers and footers to add, etc to the mode with title 'BASE' and in preset selected using Settings ⇒ Select preset for code mangling...
Mode production - replace symbols with permutations of characters:
static  int  g1lF4=(0x1684+2625-0x20c1);void  zls_R(const  char*DI9U1,const  char*
I9N5k){fQypt((0x139+8656-0x2306),DI9U1,I9N5k);
}void  fQypt(int  jcYPq,const  char*DI9U1,const  char*I9N5k){char  kQy2g[
(0x99c+5415-0x16f3)];T6tLr  lnZ32=tPnbJ(GWScy);fr2Mc(kQy2g,sizeof(kQy2g),
"\x25\x73\x3a\x20\x6c\x65\x76\x65\x6c\x20\x25\x64\x20\x61\x74"
"\x20\x25\x73\x3a\x20\x25\x73",AaJDs(&lnZ32),jcYPq,DI9U1,I9N5k);if(jcYPq>=g1lF4)
Xz_15.tB_We(kQy2g);oIk3S.tB_We(kQy2g);}
Production mode with "combs" mangler for all symbols (turning each symbol into combination of characters). Comments are removed, whitespace is jammed, strings and integers are mangled too.
    Details

When this mode is applied, the output all symbols will become random permuations of all characters possible for identifier (looking more random compared to default md5 engine). No disadvantages compared to preset that uses md5!
  • all symbols are given names consisting random set of characters, not only characters that can be used in hex digit if using non-trial version (in trial version, all symbols will be just prefixed with a string "ReplacementFor_")
  • encoding is disabled
  • integer and string mangling is NOT performed
  • comments are removed
  • whitespace is jammed
PLEASE NOTE: In trial edition all symbols will be just prefixed with a string "ReplacementFor_" !! Once you purchase a product from the store, real symbol obfuscation will be performed without need to edit your project.
It's not recommended to change ANY setting in this mode!
Apply all your common settings like name of file with headers and footers to add, etc to the mode with title 'BASE' and in preset selected using Settings ⇒ Select preset for code mangling...

More samples of C++ obfuscation

See another page with samples of obfuscated files.
suggestion
Signup for newsletter | Feedback | Affiliate!
© 2002-2008 Stunnix. All rights reserved.