Obfuscated Code

[JMJ_coder]

This is my first exercise in code obfuscation. This is a legal C program and will compile (tested gcc and pcc) -- I'll let you guess what it does before I tell you (don't cheat by running it).

_(__,___,____,_____){(__)?printf("%d\n",____),_(__-_____,____,___+____,_____):0;}main(){_(25,0,1,1);}

[TerryP]

I don't know what's more evil, that I can actually read that fine or that you actually compiled it.

[ephemera]

It's valid C code.

Here's the de-obfuscated code:

/*
        a recursive fibonacci generator to print upto:
            (arg1+arg4)/arg4 fib's if (arg4 > 1 && arg4 < arg1)
            arg1 fib's if (arg4==1 && arg4 <= arg1)
        starting with the numbers arg2 and arg3 (assuming arg3 == arg2+1 || arg2 == arg3 == 1 && arg2 >= 0)
*/
fib_gen(arg1,arg2,arg3,arg4)
{
        (arg1) ?
        /* printf(...); (void) fib_gen(...); */
        printf("%d\n", arg3), fib_gen(arg1-arg4, arg3, arg2+arg3, arg4)
        :
        0;
}

main()
{
        fib_gen(25,0,1,1);
}

So, what prize am I getting?

[JMJ_coder]

Originally Posted by ephemera

It's valid C code.

Here's the de-obfuscated code:

/*
        a recursive fibonacci generator to print upto:
            (arg1+arg4)/arg4 fib's if (arg4 > 1 && arg4 < arg1)
            arg1 fib's if (arg4==1 && arg4 <= arg1)
        starting with the numbers arg2 and arg3 (assuming arg3 == arg2+1 || arg2 == arg3 == 1 && arg2 >= 0)
*/
fib_gen(arg1,arg2,arg3,arg4)
{
        (arg1) ?
        /* printf(...); (void) fib_gen(...); */
        printf("%d\n", arg3), fib_gen(arg1-arg4, arg3, arg2+arg3, arg4)
        :
        0;
}

main()
{
        fib_gen(25,0,1,1);
}

So, what prize am I getting?

I'm impressed -- you even came close to the original function name fib().

Three cheers for ephemera!

[JMJ_coder]

So, how did I do on my first attempt at obfuscation? Was it hard to understand? easy to decipher? etc.?

[TerryP]

Interesting, no, and yes, lol.

All I had to do, was count the underscores to find which identifiers were which, as soon as I spotted the recursive call (~3 seconds later) it was obvious that displays a sequence of 25 numbers. The only 'hard' part was double checking if the sequence were fibonacci numbers, if you call that hard. (I stopped thinking after mentally compiling '5').


Maybe try writing a java virtual machine in brainfuck next time? hehe.

[Carpetsmoker]

Maybe try writing a java virtual machine in brainfuck next time? hehe.

I think anyone trying to do that will soon have an obfuscated brain.

[ephemera]

Originally Posted by JMJ_coder

So, how did I do on my first attempt at obfuscation? Was it hard to understand? easy to decipher? etc.?

TBH, I didn't find it too hard to decipher. But, did you make this on your own?
If so, it's a good effort - in particular I liked your use of recursion!

[JMJ_coder]

Originally Posted by ephemera

TBH, I didn't find it too hard to decipher. But, did you make this on your own?
If so, it's a good effort - in particular I liked your use of recursion!

I followed some tips from Wikipedia (e.g., use recursion instead of iteration, ?: instead of if-else, etc.), but I wrote the program and converted to obfuscated code myself.

[ephemera]

Cool.

Somehow obfuscation never caught my fancy.
Anyway, any code of some size and complexity without good comments is obfuscated enough for me.

You might have probably seen this one, its cool: http://www.cs.uleth.ca/~holzmann/C/C/cselfprint.html

[TerryP]

if you want to use the ?: trinary/ternary operator to obfuscate things, be sure to nest them in strange and deranged ways, and slip in comma's and garbage values anywhere you can.


In my personal opinion, good code should be fairly obvious even without comments, and the comments should be free to provide 'commentary' and annotations instead of explaining away physical laziness. e.g.

/* push element onto int stack */ istk_t istkp(iskt_t *s, iskt_t *e);  

vs 

istack_t istack_push( istack_t *stk, istack_t *elem);

where the latter speaks for itself, documenting all but the 'i' part. And a proper comment in the istack module might explain what the heck the it is, and hopefully it's purpose and use should be known in a few minutes of code browsing even without it. You could say, I hate anything that I need to read more any furhter then the header file in order to use it....



Those bastardo 2000+ line procedures some people write on the other hand, just need to be drawn and quartered ;-)

[s2scott]

I'm sensing you guys would have liked APL.

/S

[jggimi]

I used to be an APL programmer, back in the late '70s. And through until around 1981, or so, when I moved to systems programming (today, that would be systems administration, but back then, we modified our OSes to meet requirements).

APL had some interesting capabilities, helpful for financial analysis applications (I was working for a commodities trading firm). Special keyboards and terminals were needed, however.

I did end up learning how to pronounce and spell most of the Greek alphabet, of course, as any APL programmer would. But along with Ro and Pho and Theta, we also used words to describe symbolic functions that were not Greek. The left and right arrows, for example, were called the "guzinta" and "guzouta".

One could write a line of code that would perform an operation on a large vector of numbers, that might contain, for example, twenty thousand integers, all at once. But, if the programmer misplaced a comma, rather than making a single arithmetic operation on twenty thousand numbers at once, one would instead execute twenty thousand individual operations. You'd get the same results, but thousands of times more slowly. Just from putting the comma in the wrong place.

I moved from APL to S/370 Assembler. The latter was so much clearer and easier to understand.

[TerryP]

The number of people who have received :wq! and kkkkk messages from me, are living prove that I could never program in APL or any language needing a special keyboard, even if I think leaving near-ASCII behind is a Good Thing.

[ephemera]

No one pointed it out; there is a possible integer overflow if the no. of fibs is > 48.