Hi all, this is my second post on C code obfuscation. You can check out all my posts on obfuscation here.

In this post, we’ll see two techniques which one can use in C code obfuscation. The more we apply these to our code, the more obfuscated our code will result in. And of course, this is not the complete guide for obfuscation. Just the two important techniques I find interesting. :-)

Recursion
The first one is recursion. Yes recursion. :-) Well, before we start recursion we should know this. “To iterate is human, but to recurse is divine.” ;-). The great point about recursion is that it can make any simple code complicated. Before I explain what I’m going to do, let me post the code final code here.

T
=__LINE__;
#define FF T*T*T*T*T+T*T*T+T*T*T*T-T/T
char *___="He that falls in love with himself will have no rivals.";_$_(int _,int __){(__-_==(T/T)?printf("%c",*(___+_)):(_$_(_,(__-_)/T+_),_$_((__-_)/T+_, __)));}main(){_$_(T-T, FF);}

The code simply prints the quote “He that falls in love with himself will have no rivals.”, quoted by Benjamin Franklin.

So let us start with a simple code which does that.
#include <stdio.h>
int main() {
    printf("He that falls in love with himself will have no rivals.");
    return 0;
}

Now, let us see how to introduce recursion into this. You can say, to print a string, first print the first half of the string and then the second half of the string. Got it? Yes, it is like this

Print the string
    Print the first half of the string
        Print the first half of the first half of the string
        …
        …
        
        Print the second half of the first half of the string
        …
        ….
    Print the second half of the string
        Print the first half of the second half of the string
        …
        …
        
        Print the second half of the second half of the string
        …
        …

After we introduce recursion into this logic, we get a code similar to the following. Again, the code can be made further complicated. Just remember, there is no limit to obfuscation.

#include <stdio.h>
char *str = "He that falls in love with himself will have no rivals.";
void print(int start, int end) {
    if (end-start==1) {
        printf("%c", *(str+start));        
    }
    else {
        print(start, (end-start)/2+start);
        print((end-start)/2+start, end);
    }
}
int main() {
    print(0, 55);
    return 0;
}


Next, we remove the 2 in the else part of the code using #define. I use __LINE__ in this example. :). So now the code looks like this.

#include <stdio.h>
t=__LINE__;
char *str = "He that falls in love with himself will have no rivals.";
void print(int start, int end) {
    if (end-start==1) {
        printf("%c", *(str+start));        
    }
    else {
        print(start, (end-start)/t+start);
        print((end-start)/t+start, end);
    }
}
int main() {
    print(0, 55);
    return 0;
}

Next, we remove the if else in the print statement and have a single conditional statement. That changes the whole picture in the print function, as shown below.

#include <stdio.h>
t=__LINE__;
char *str = "He that falls in love with himself will have no rivals.";
void print(int start, int end) { (end-start==1?printf("%c", *(str+start)):(print(start, (end-start)/t+start),print((end-start)/t+start, end))); }
int main() {
    print(0, 55);
    return 0;
}

Finally we change all the variable names so that they have only _’s and remove unnecessary space. Also you can change the value 55 to as 32+16+8-1 (all of these generated only using the previously used 2). So this is the final code. :)

T
=__LINE__;
#define FF T*T*T*T*T+T*T*T+T*T*T*T-T/T
char *___ = "He that falls in love with himself will have no rivals.";_$_(int _,int __){(__-_==1?printf("%c", *(___+_)):(_$_(_,(__-_)/T+_),_$_((__-_)/T+_, __)));}main(){_$_(T-T, FF);}


Preprocessor Statements
The second technique I find interesting is using #ifdef, #else, #endif and #include. You can make any code obfuscated without much programming.

Again, let us take the same simple code to explain the usage of preprocessor statements. Though it is much more effective when you apply this to an obfuscated code.

So the sample code with which we start will be

#include <stdio.h>
int main() {
    printf("He that falls in love with himself will have no rivals.");
    return 0;
}

The resultant obfuscated code will be


#ifdef T1
    #ifdef T2
        #ifdef T3
            #ifdef T4
                }    //Line 5
            #else
                #define T4
                return 0;    //Line 4
                #include __FILE__
            #endif        
        #else
            #define T3
            printf("He that falls in love with himself will have no rivals.");    //Line 3
            #include __FILE__
        #endif
    #else
        #define T2
            int main() { //Line 2
        #include __FILE__
                
    #endif
#else
    #define T1
        #include <stdio.h> //Line 1
    #include __FILE__
#endif

I guess I can’t explain much on this. This is one simple concept in which preprocessor complies selected lines and then the same file is included again. :) If the above code is confusing, read this article on preprocessing and then try some simple code using this idea. Then this code will be a cakewalk.

You can download all the C files as a single zip file here.

Hello, this is the first post I’m writing on C code obfuscation. Let me warn you before I start. I am a beginner in code obfuscation and still learning from different code snippets I get from my friends.

Since this is the first post in this series, we will start with hello world. But instead of printing the same old hello world, we will print the quote “He that falls in love with himself will have no rivals.”, quoted by Benjamin Franklin.

We need a simple base program to start with right? The following code prints the quote.

#include
int main() {
char s[123] = "He that falls in love with himself will have no rivals.";
printf("%s", s);
return 0;
}

Surely, that is not the obfuscated code. First, let us convert the string into character array and instead of printing the string, we print the character array. Simple right? So the code now looks like this.

#include
int main() {
int i;
char s[] = {'H','e',' ','t','h','a', 't', ' ', 'f', 'a', 'l', 'l', 's', ' ', 'i', 'n', ' ', 'l', 'o', 'v', 'e', ' ', 'w', 'i', 't', 'h', ' ', 'h', 'i', 'm', 's', 'e', 'l', 'f', ' ', 'w', 'i', 'l', 'l', ' ', 'h', 'a', 'v', 'e', ' ', 'n', 'o', ' ', 'r', 'i', 'v', 'a', 'l', 's', '.'};
for (i=0; i<55; i++) {
printf("%c", s[i]);
}
return 0;
}


Next step, we take the two variables “i” and “s” outside the main. Since now the two variables are in global scope, if we don’t define the data type, it is an integer by default. Since we can define a character array as an integer array, we need not provide the datatype for both the variables. So now the code looks like this. Also we can change “int main” to “main” and remove the “return 0;” statement.

Note:: This idea of not defining the data type shouldn’t be used if you are practising for IOCCC. In there, the guidelines clearly states the following.
When declaring local or global variables, you should declare the type:

int this_is_ok;
this_is_not; <-- don't use such implicit type declarations

i, s[] = {'H','e',' ','t','h','a', 't', ' ', 'f', 'a', 'l', 'l', 's', ' ', 'i', 'n', ' ', 'l', 'o', 'v', 'e', ' ', 'w', 'i', 't', 'h', ' ', 'h', 'i', 'm', 's', 'e', 'l', 'f', ' ', 'w', 'i', 'l', 'l', ' ', 'h', 'a', 'v', 'e', ' ', 'n', 'o', ' ', 'r', 'i', 'v', 'a', 'l', 's', '.'};
main() {
for (i=0; i<55; i++) {
printf("%c", s[i]);
}
}

Next, we remove the 55 to the size of the array. We need to replace 55 by “sizeof(s)/sizeof(int)”. Let us do that in a better way as shown below. The two preprocessor statements added below to replaces ck by sizeof(s)/sizeof(int). The point to note here is that we have added the preprocessor statements in between the for statement.


i, s[] = {'H','e',' ','t','h','a', 't', ' ', 'f', 'a', 'l', 'l', 's', ' ', 'i', 'n', ' ', 'l', 'o', 'v', 'e', ' ', 'w', 'i', 't', 'h', ' ', 'h', 'i', 'm', 's', 'e', 'l', 'f', ' ', 'w', 'i', 'l', 'l', ' ', 'h', 'a', 'v', 'e', ' ', 'n', 'o', ' ', 'r', 'i', 'v', 'a', 'l', 's', '.'};
main() {
for (i=0;
#define f(z) sizeof(z)
#define ck f(s)/f(int)
i<ck; i++) {
printf("%c", i[s]);
}
}

Since i is a global variable, we need not initialize the value to 0. Again, we can remove the i++ statement by changing s[i] to s[i++]. And also note that a[i] and i[a] are both the same. So we can use i++[s]. So the code now becomes

i, s[] = {'H','e',' ','t','h','a', 't', ' ', 'f', 'a', 'l', 'l', 's', ' ', 'i', 'n', ' ', 'l', 'o', 'v', 'e', ' ', 'w', 'i', 't', 'h', ' ', 'h', 'i', 'm', 's', 'e', 'l', 'f', ' ', 'w', 'i', 'l', 'l', ' ', 'h', 'a', 'v', 'e', ' ', 'n', 'o', ' ', 'r', 'i', 'v', 'a', 'l', 's', '.'};
main() {
for (;
#define f(z) sizeof(z)
#define ck f(s)/f(int)
i<ck;
)
printf("%c", i++[s]);
}

Next, we remove the extra spaces so that the code is “poorly” aligned, as shown below. Also, now, we can replace the variable names by _ and __ etc. I haven’t done much to the character array here. That is not the aim of this post. Will write a separate post on manipulating strings. But for now, we can convert the character array to hexadecimal or octal numbers. ;-) (This is not the best way to obfuscate it though).

So the final code looks something like this.

#define ____(z) sizeof(z)
_, __[] = {0x48, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x66, 0x61, 0x6c, 0x6c, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x6c, 0x6f, 0x76, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x68, 0x69, 0x6d,0x73, 0x65, 0x6c, 0x66, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20,0x68, 0x61, 0x76, 0x65, 0x20, 0x6e, 0x6f, 0x20, 0x72, 0x69, 0x76, 0x61, 0x6c, 0x73, 0x2e}; main() { for (;
#define ___ ____(__)/____(int)
_<___;) printf("%c", _++[__]);}

All suggestions on still screwing up this code are welcome. ;-)

Update: You can download all the C files as a single zip file here.