I’ve been thinking about not only announcing releases and features, but also discuss (read: point and laugh at) some very common annoyances. I hope to one day be seen as a meaner alternative to The Daily WTF but with less free mugs and more open source. Anyway, on to this post’s subject…
Open Binary – source code so obfuscated, “optimized” and arcane that despite an open source license nobody can edit or benefit from reading it. Your only hope is to compile it into a binary and hope it works. There are plenty of examples of this in the video world, such as mplayer, most popular Avisynth filters and to be honest almost every single piece of code written in the field of video processing.
So how do you produce an Open Binary? Well, in my opinion you have to put effort into multiple levels to succeed. For example one important step is to OPTIMIZE! And by that I mean bitwise shifts! No compiler can ever figure out that a/2 can be compiled to a right shift so you have to help it, it also makes the code faster. Another important detail to know about CPUs, even the most modern ones, are that they are slow readers. Armed with this knowledge make all variable names short so there’s less to read for the poor CPU. For text parsing we can actually do one better since modern CPUs are good at numbers, simply use the ascii code instead of the letter in any text operation.
An example of proper text parsing taken from TIVTC:
if (*linep != 0)
{
qt = -1;
d2vmarked = false;
*linep++;
q = *linep;
if (q == 112) q = 0;
else if (q == 99) q = 1;
else if (q == 110) q = 2;
else if (q == 98) q = 3;
else if (q == 117) q = 4;
else if (q == 108) q = 5;
else if (q == 104) q = 6;
else
{
fclose(f);
f = NULL;
env->ThrowError("TFM: input file error (invalid match specifier)!");
}
*linep++;
*linep++;
...continued for several hundred lines
There are several other techniques you can use too, for example writing pure assembler, or even better, inline assembler which effectively will tie all your code to one platform and compiler too at the same time in addition to being near impossible for anyone to modify or understand! You can also play the shell game with pointers and global variables, have one function add an offset to a pointer and pass it to the next which subtracts it again. The secret it is to put spaghetti in your sauce, so to say.
So who should use this approach to leverage the open source benefits? Big evil companies of course! Sure, you’ll have to reveal the source code but no one can ever use it for anything anyway. This is the end of part one of my “Business Strategies for the Modern Monopolist” series. I’ll be posting part two shortly.
Here’s a final example of successful use of assembler only to make a true Open Binary, again from TIVTC as I’ve spent far too much time staring at it recently. The actual post ends here so you don’t have to scroll down to look for more.
__asm
{
mov y, 2
yloop:
mov ecx, y0a
mov edx, y1a
cmp ecx, edx
je xloop_pre
mov eax, y
cmp eax, ecx
jl xloop_pre
cmp eax, edx
jle end_yloop
xloop_pre:
mov esi, incl
mov ebx, startx
mov edi, mapp
mov edx, mapn
mov ecx, stopx
xloop:
movzx eax, BYTE PTR [edi+ebx]
shl eax, 3
add al, BYTE PTR [edx+ebx]
jnz b1
add ebx, esi
cmp ebx, ecx
jl xloop
jmp end_yloop
b1:
mov edx, curf
mov edi, curpf
movzx ecx, BYTE PTR[edx+ebx]
movzx esi, BYTE PTR[edi+ebx]
shl ecx, 2
mov edx, curnf
add ecx, esi
mov edi, prvpf
movzx esi, BYTE PTR[edx+ebx]
movzx edx, BYTE PTR[edi+ebx]
add ecx, esi
mov edi, prvnf
movzx esi, BYTE PTR[edi+ebx]
add edx, esi
mov edi, edx
add edx, edx
sub edi, ecx
add edx, edi
jge b3
neg edx
b3:
cmp edx, 23
jle p3
test eax, 9
jz p1
add accumPc, edx
p1:
cmp edx, 42
jle p3
test eax, 18
jz p2
add accumPm, edx
p2:
test eax, 36
jz p3
add accumPml, edx
p3:
mov edi, nxtpf
mov esi, nxtnf
movzx edx, BYTE PTR[edi+ebx]
movzx edi, BYTE PTR[esi+ebx]
add edx, edi
mov esi, edx
add edx, edx
sub esi, ecx
add edx, esi
jge b2
neg edx
b2:
cmp edx, 23
jle p6
test eax, 9
jz p4
add accumNc, edx
p4:
cmp edx, 42
jle p6
test eax, 18
jz p5
add accumNm, edx
p5:
test eax, 36
jz p6
add accumNml, edx
p6:
mov esi, incl
mov ecx, stopx
mov edi, mapp
add ebx, esi
mov edx, mapn
cmp ebx, ecx
jl xloop
end_yloop:
mov esi, Height
mov eax, prvf_pitch
mov ebx, curf_pitch
mov ecx, nxtf_pitch
mov edi, map_pitch
sub esi, 2
add y, 2
add mapp, edi
add prvpf, eax
add curpf, ebx
add prvnf, eax
add curf, ebx
add nxtpf, ecx
add curnf, ebx
add nxtnf, ecx
add mapn, edi
cmp y, esi
jl yloop
}
