ARCHIV

Perl (141) - Formátování kódu, deparsování, perltidy

Co když někdo záměrně napsal nečitelný kód a my chceme zjistit, jak jeho program funguje? Máme šanci? Nebo naopak, pomůžeme si tím, když chceme svůj kód uchránit? Jak Perl chápe náš kód?

8.9.2011 19:00 | Jiří Václavík | Články autora | přečteno 10457×

Nahlédněme dnes trochu do vnitřností Perlu. Podíváme se, jak zjistit, jakým způsobem Perl chápe kód.

Na třídě všech programů v Perlu lze nalézt (netriviální) ekvivalenci, která tuto třídu faktorizuje na podtřídy tak, aby každá třída ekvivalence obsahovala programy, které Perl chápe stejně. Výraz "chápe stejně" znamená, že je kompiler přeloží do stejných instrukcí. Tento výrok je sice v podstatě tautologický, ale minimálně je zajímavé si jeho pravdivost uvědomit.

Díky modulu B::Deparse lze každý zdrojový kód převést na něco jako standardizovanou formu. Tento modul funguje tak, že nejprve převede zdrojový kód do nějakých instrukcí, kterým rozumí jen Perl. Zobrazení ze zdrojového kódu do interních instrukcí není prosté. Následně B::Deparse provede inverzní proces, čímž získáme opět zdrojový kód. Protože ono první zobrazení nebylo prosté, může se tento kód od původního lišit.

Příklad

Co dělá následující kód?

$_ = "abcdefgh";
s$g$g$g;
print

Vypadá to jako překlep, ale po spuštění interpret nezahlásí žádnou chybu.

$ perl -w kod.pl
abcdefgh
$

Toto je poměrně jednoduchá ukázka, navíc nám pomohlo zvýraznění syntaxe. Lze tedy tušit, že prostřední řádek znamená substituci s trochu netradičním oddělovačem. Podívejme se ale, co nám řekne B::Deparse.

$ perl -MO=Deparse test.pl
$_ = 'abcdefgh';
s/g/g/g;
print $_;
test.pl syntax OK
$

Na našem kódu se změnilo několik věcí. Především, v prostředním řádku se změnil oddělovač z dolaru na lomítko, odkud je hned jasné, že je to skutečně substituce. Dále byly ještě nahrazeny uvozovky apostrofem a výchozí proměnná byla uvedena všude tam, kde došlo k její použití.

Řetězec test.pl syntax OK je vypsán na STDERR, pokud je kód validní. V opačném případě jsou vypsány chyby, nicméně B::Deparse se pokusí aspoň zčásti kód vytisknout.

Nečitelný kód

B::Deparse nepředstavujeme ani tak kvůli praktickému využití jako spíš zajímavost, pomocí které lze pochopit řadu věcí tak, jak je chápe překladač.

Avšak někdy se může modul B::Deparse hodit například i pro pochopení toho, jak fungují nečitelné programy.

Nejlepším zdrojem pro nečitelné programy v Perlu je tzv. Obfuscated Perl Contest, což bývala soutěž o nejnečitelnější kód. Podívejme se na následující program.

@P=split//,".URRUU\c8R";@d=split//,"\nrekcah xinU / lreP rehtona tsuJ";sub p{
@p{"r$p","u$p"}=(P,P);pipe"r$p","u$p";++$p;($q*=2)+=$f=!fork;map{$P=$P[$f^ord
($p{$_})&6];$p{$_}=/ ^$P/ix?$P:close$_}keys%p}p;p;p;p;p;map{$p{$_}=~/^[P.]/&&
close$_}%p;wait until$?;map{/^r/&&<$_>}%p;$_=$d[$q];sleep rand(2)if/\S/;print

Spustíme-li ho, vypíše se pomalu text

Just another Perl / Unix hacker

Jak ale tento program skutečně funguje, to je záhada možná i na několik hodin. V případě, že nepoužijeme B::Deparse. Zkusme aplikovat B::Deparse na předchozí program. Dostaneme již podstatně přátelštější kód.

@P = split(??, '.URRUUxR', 0);
@d = split(??, "\nrekcah xinU / lreP rehtona tsuJ", 0);
sub p {
    @p{"r$p", "u$p"} = ('P', 'P');
    pipe "r$p", "u$p";
    ++$p;
    ($q *= 2) += $f = !fork;
    map {$P = $P[$f ^ ord $p{$_} & 6];
    $p{$_} = / ^$P/xi ? $P : close $_;} keys %p;
}
p ;
p ;
p ;
p ;
p ;
map {close $_ if $p{$_} =~ /^[P.]/;} %p;
wait until $?;
map {<$_> if /^r/;} %p;
$_ = $d[$q];
sleep rand 2 if /\S/;
print $_;

Sice se nedá říct, že bychom už na první pohled mohli přesně říci, co se děje, ale již nás asi napadne, že různé části textu jsou tisknuty různými procesy a jejich synchronizace probíhá pomocí rour. Použití B::Deparse nebo nástroje perltidy by měl být první krok při čtení takto nepřehledného kódu.

Zajímavý příklad

Poradí si opravdu B::Deparse s jakýmkoliv kódem? Pro zpestření si ještě jednou pro inspiraci sáhněme do soutěže Obfuscated Perl Contest. Zde je další zajímavý program.

#:: ::-| ::-| .-. :||-:: 0-| .-| ::||-| .:|-. :||
open(Q,$0);while(<Q>){if(/^#(.*)$/){for(split('-',$1)){$q=0;for(split){s/\|
/:.:/xg;s/:/../g;$Q=$_?length:$_;$q+=$q?$Q:$Q*20;}print chr($q);}}}print"\n";
#.: ::||-| .||-| :|||-| ::||-| ||-:: :|||-| .:|

Zkusme ho spustit.

$ perl kod.pl
The Perl Journal
$

A jak funguje? Zkusme na něj použít nám známý modul B::Deparse, který nám kód promění do podoby, v jaké ji chápe Perl.

$ perl -MO=Deparse poc.pl
open Q, $0;
while (defined($_ = )) {
    if (/^#(.*)$/) {
        foreach $_ (split(/-/, $1, 0)) {
            $q = 0;
            foreach $_ (split(' ', $_, 0)) {
                s/\|
/:.:/gx;
                s/:/../g;
                $Q = $_ ? length $_ : $_;
                $q += $q ? $Q : $Q * 20;
            }
            print chr $q;
        }
    }
}
print "\n";
poc.pl syntax OK
$

Výstup si uložme do souboru a pošleme na něj interpret Perlu. Výsledek nás asi překvapí, protože se nic nevypíše. Proč zde B::Deparse nefunguje?

Ve skutečnosti B::Deparse funguje, problém je někde jinde. Nahlédněme zpět do zdrojového kódu, přesněji hned na první řádek. Tento skript je totiž zároveň jak programem, tak jeho daty. Program parsuje svůj vlastní kód a z komentářů extrahuje data. Ale B::Deparse všechny komentáře odstraní a tím pádem se kód stává nefunkční. Musíme tedy nejprve přidat ony dva komentáře.

perltidy - nástroj na formátování kódu

Pokud nám jde čistě o zpřehlednení kódu, je na to asi nejlepším nástrojem příkaz perltidy. Tento nástroj umí formátovat zdrojový kód Perlu několika způsoby.

Zavoláním následujícího příkazu se kód přeformátuje do podoby, která by měla co nejvíce odpovídat manuálové stránce perlstyle(1). Na výstupu vznikne soubor program.pl.tdy.

$ perltidy program.pl

Kdo má raději formátování GNU, může přidat příslušný přepínač.

$ perltidy -gnu program.pl

Zajímavé je také HTML zvýrazňování syntaxe. Přidáním -html dostaneme v souboru program.pl.html HTML stránku.

$ perltidy -html program.pl

Další možnosti tohoto nástroje nalezneme v dokumentaci.

Verze pro tisk