Roger on that obfu working. And it is a "precioussssss" obfu, if I may say so. Thanks for the fun and for making me remeber "my precioussss", maverick.

I dont know if it's good PM etiquete to discuss the functioning of an obfu, but that's the fun of it, so here it goes a first look into it Warning, spoiler ahead:

The main code is inside the first interpolation q. That code goes into the @d array, wich is reordered in the for at the bottom

for(my $i=0;$i<$#d/2;$i+=2) {
  my $t=$d[$i];
  $d[$i]=$d[$#d-$i];
  $d[$#d-$i]=$t
}
[download]

This reorders all that code in @d, swapping every third line with the one that has the same index if you started counting from the end of the @d

So, doing the swap we get the code that will be run, wich I formated for your viewing pleasure :

my $h = [[['t','o'],[['d','i'],'n']],[[['s','r'],['l','h']],['e',[['m'
+,['f','b']]
,[[['k',['w','p']],['g','u']],'a']]]]];
my $m = '_001011110^_001_1000.000001.100111110111010110^00010111101110
+0.111111010
1010b_001011110._001_1000^000001.11101001010110100.000101111011100d_00
+101111
0._001_1000^000001.111011100101010111111010.000101111011100.1111110101
+010b_1
11110110100^0101011^0001011110._0100111111001111100001111010001000^111
+011010
10110100.000101111011100b_0101011^0001011110^_1010111110110100^0011110
+10._10
011100100111000010110100^1111001010111101001110^0001011110._11110011_1
+001.10
1001011101000d^....^^...^...^^..--._0001011110^_101000110010100^001111
+010.00
01011110._1001010101111110101000bb1111001011010101010c.100000110010001
+1111';

$m =~s!\s!!g;
my %h=('^',' ','.',' ','b',"\n",'d',"\n",'c',',','e',',','-','-',);
my $u;

sub d {
  my($t,$d)=@_;
  if(ref($t)) {
    my $c=shift @{$d};
    while($c !~ /^\d$/x && length $c) {
      ($c eq'_') ? $u=1 : print $h{$c};
      $c = shift@{$d};
    }
    return d($t->[$c],$d);
  } 
  else {
    if ($u) {
      $u=0;
      print uc($t);
    } 
    else {
      print $t;
    }
    return @{$d};
  }
}

my @d = split//,$m;

while(scalar @d) {
  @d = d($h,\@d);
} 
print"\n";
[download]

It now looks much better, but the thing is, now it's realy getting harder.

Maverick used the sub d, with an array called d passed by reference and that gets changed in there, adding a new level to this obfuing (am I coining a term here ? ;^).The recursive call to sub d inside almost made me croak ;-)

OK, the main idea is that the binary string in $m (later splited into an array with each of its characters in @d) will be used in sub d to choose wich of the sub-arrays and elements of $h will be used.

Zeros make the array get shifted, ones means that that particular sub array will be used. The shifting occurs in the recursive call to d.

Each time a element of the array is reached (i.e. a character), as it's not a reference to an array, it will get printed (in upper case depending on a flag set by the _ in the control stream (er, $m), with some more caracters provided by %h.

This was a very nice use of recursion, passing arrays by ref, acessing arrays inside arrays of an array passed by reference, interpolation, eval, etc.

Until today, I wondered why people did obfuscation. It seamed just a way to use the worst of perl, the most arcane syntax and realy, just a bad thing to throw at people who are trying to grasp the elementary stuff in perl.

Well, i can now see *two* good motives for doing it,

one : you've got to learn (or know how to use) some of the hard but usefull things in perl and sometimes it makes to you run to documentation

two : it's Major fun

three : your ability to do math gets improved ;^)

Thanks again to maverick and to all obfuers in general :-)

Comment on Re: With apologies to J.R.R (explained) Select or Download Code