Junk генератор Perl-код для запутывания

Question

Имея код:

Line1 
Line2 
.. 
LineN 

Я хочу, чтобы автоматически производить

Line1 
JunkLines2-100 
Line2 
JunkLines102-200 
Line3 
    etc. 

где JunkLines является Perl вредного кода, который не изменяет состояние программы, но выглядит как продолжение законную программу.

Я не хочу запутывать свой код с помощью обфускаторов, которые, скажем, переименовывают имена переменных в нечто нечитаемое - эта нечитаемость является сигналом, что код запутан.

Answer 1

Я не понимаю, почему так много downvotes: это выглядит как интересная проблема.

У меня было немного свободного времени, и пытался что-то на моих:

• код для мусора находится в отдельном файле с блоками, разделенными # ---
• Ofuscator изменяет имена переменных и функций в мусоре код, если это существует в оригинальном хорошем коде (я предположил, что вы определить переменные с my и функции с sub)
• Ofusctaor случайным образом при добавлении контента из мусора файла (зацикливание при необходимости)

Это выглядит как этот

Хороший код (original.pl)

#!perl 
use strict; 

my $var1='hello'; 
my $var2='there'; 

sub f { 
    print "This is a function"; 
    ++$var1 
} 

print $var1; 
print "\n$var2"; 

Garbage код (garbage_code.pl)

#!perl 
#--- 
my $var2='__NEW'; 
my $var3="This is garbage"; 
#--- 
sub g { 
    $var3+="changed"; 
    print "This shall be removed"; 
    return $var3; 
} 
#--- 
sub f { 
    return g(shift).$var2; 
} 
#--- 
f("function name shall be changed"); 

Offuscator

#!perl 
use strict; 
use Data::Dumper; 

#-Get Original 'good' code 
open CODE,"<original.pl" or die $!; 
my @code=<CODE>; 
close CODE; 

#-Get Garbage code 
open GARBAGE,"<garbage_code.pl" or die $!; 
my @garbage=split(/^#---/m, join("",<GARBAGE>)); 
shift @garbage; #Remove header 
map { s/^.*?(\w.*?)\s*$/\1/s } @garbage; #Trail spaces and EOL at beginning and end 
map { s/print .*?;//g } @garbage; #Remove print calls 
close GARBAGE; 

#-List variables and functions in good code 
my %list_var; 
my %list_func; 
for my $line (@code) { 
    if ($line=~/my \s*[\$@%](\w+)/) { $list_var{$1}=undef; } 
    elsif ($line=~/sub \s*(\w+)/) { $list_func{$1}=undef; } 
    else { } 
} 

#-List variables and functions in garbage code 
my @list_var_garbage; 
my @list_func_garbage; 
for my $line (@garbage) { 
    while ($line=~/my \s*[\$@%](\w+)/g) { push(@list_var_garbage,$1); } 
    while ($line=~/sub \s*(\w+)/g) { push(@list_func_garbage,$1); } 
} 

#-Replace names of variables and functions in garbage code if it exists in good code 
#Get equivalent name 
for my $type ('var', 'func') { 
    my $rh_list = ($type eq 'var' ? \%list_var : \%list_func); 
    my @list_names=(keys %$rh_list, ($type eq 'var' ? @list_var_garbage : @list_func_garbage)); 
    for my $name (@list_names) { 
     #Get new name 
     my $new_name=$name; 
     #For names of good code OR new names in garbage code 
     if (!defined $rh_list->{$new_name}) { 
      while (exists $rh_list->{$new_name}) { $new_name.="1"; } 
      #Store in hash table 
      $rh_list->{$new_name}=undef; #to ensure uniqueness of replacements 
      $rh_list->{$name}=$new_name; #Replacement name in garbage code 
     } else {} 
    } 
} 
#Replace 
map { s/(?:sub \s*|&)\K(\w+)/$list_func{$1}/g } @garbage; 
map { s/(\w+)\(/$list_func{$1}(/g } @garbage; 
map { s/[\$@%]\K(\w+)/$list_var{$1}/g } @garbage; 


#-Function to get garbage content 
my $i_garbage=0; 
sub get_garbage { 
    return $garbage[ ($i_garbage++) % scalar(@garbage) ]."\n"; 
} 


#-Copy garbage in good code 
my @new_code; 
for my $line (@code) { 
    #-Add the line 
    push(@new_code, $line); 

    #-Add garbage 
    #Blocks: add garbage at the end 
    if ($line=~/\{/ .. $line=~/\}/) { 
     if ($line=~/\}/) { push(@new_code, get_garbage()); } 
    #Other: randomly add garbage 
    } else { 
     if (int(rand(2))) { push(@new_code, get_garbage()); } 
    } 
} 

#Print file with new code 
open NEW_CODE, ">new.pl" or die $!; 
print NEW_CODE @new_code; 
close NEW_CODE; 

Результат

#!perl 
use strict; 
my $var21='__NEW'; 
my $var3="This is garbage"; 

sub g { 
    $var3+="changed"; 

    return $var3; 
} 
my $var1='hello'; 
sub f1 { 
    return g(shift).$var21; 
} 
my $var2='there'; 

f1("function name shall be changed"); 
sub f { 
    print "This is a function"; 
    ++$var1 
} 
my $var21='__NEW'; 
my $var3="This is garbage"; 

sub g { 
    $var3+="changed"; 

    return $var3; 
} 
print $var1; 
print "\n$var2"; 
sub f1 { 
    return g(shift).$var21; 
} 

f1("function name shall be changed"); 

Это, вероятно, не принимать во внимание все случаи, но это, безусловно, хорошо работающий прототип.

Cheers

Answer 2

Я не уверен, что вы получаете отрицательные голоса из-за отсутствия информации или чего-то еще, но это относительно простое решение. Предполагая, что вы хотите сделать это в Perl:

Просто создайте еще один файл perl, который читает в вашем файле по одной строке за раз, распечатывает его в новый файл и добавляет строку случайных бессмысленных послесловий (в этом случае, из большого файла, который, как предполагается, содержат кучу случайных строк кода Perl «obfuscatedlines.txt»)

небольшой пример:

use strict; 
use warnings; 

my @randomlines; 
open (INHANDLE, "<perlfile.pl"); 
open (OBHANDLE, "obfuscatedlines.txt"); 
open (OUTHANDLE, ">newfile.pl"); 
while(<OBHANDLE>) {push @randomlines, $_;} 
my $i=0; 
while(<INHANDLE>) 
{ 
    print OUTHANDLE $_; 
    print OUTHANDLE $randomlines[$i]; 
    $i++; 
}