Junk perl code generator for obfuscation - perl

Question

Having a code:
Line1
Line2
..
LineN
I want to automatically produce
Line1
JunkLines2-100
Line2
JunkLines102-200
Line3
etc.
where JunkLines are Perl junk code that does not change state of program but looks like continuation of legitimate program.
I don't want obfuscate my code with obfuscators that, say, rename variable names to something unreadable - this unreadability is a signal that code is obfuscated.

Answer 1

I don't understand why so many downvotes: this looks like an interesting problem.
I had some spare time and tried something on my own:
Garbage code is in a separate file with blocks separated by #---
Ofuscator is changing names of variables and functions in garbage code if this exists in original good code (I assumed you define variables with my and functions with sub)
Ofusctaor is randomly adding content from garbage file (looping if needed)
That looks like this
Good code (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 code (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;
Result
#!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");
It probably does not take into account all cases but this is definitely a good working prototype.
Cheers

Answer 2

I'm not sure if you're receiving negative votes from lack of information or what, but this is a relatively easy fix. Assuming you want to do it in Perl:
just create another perl file which reads in your file one line at a time,prints it out to a new file, and appends a line of random nonsense afterwords (in this case, from a large file which is assumed to contain a bunch of random lines of perl code "obfuscatedlines.txt")
A small example:
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++;
}