Nascondi codice malvagio: stampa i file contenenti una determinata stringa in qualsiasi punto di un albero di directory [chiuso]

Il punto di questo enigma è imparare come un codice dannoso può essere nascosto e scoperto in un programma.

Una persona sta ponendo la domanda:

Per favore, mi dia un codice che come posso cercare un file può essere nella directory attuale o nelle sue sottodirectory.

(Questa è una variante di una vera domanda che ho visto pubblicato su un sito.)

Per essere più specifici: l'OP vuole che tu scriva un programma che accetta una stringa e una directory. Attraverserà tutti i file nella directory e ricorsivamente tutte le sue sottodirectory. Per ogni file controllerà se il file contiene la stringa e, in tal caso, stamperà il nome del file. (Se lo desideri, il programma può avere funzionalità aggiuntive purché siano rilevanti per l'obiettivo principale.) Non ci sono requisiti per l'ordine di attraversamento.

Tuttavia, il compito principale di questo puzzle è quello di nascondere nel programma un codice aggiuntivo che renderà sciocco la persona che richiede il programma agli occhi dei suoi utenti / colleghi / capo / ecc. Ad esempio, stampare un testo umiliante ad un certo punto, come ad esempio: L'autore del programma non sa come programmare, dovrebbe restituire il diploma e essere licenziato. Essere creativo.

Regole:

• La soluzione non deve essere dannosa (tranne che per rendere pazzo l'OP, ovviamente). Non deve arrecare alcun danno irreversibile agli utenti finali (niente di simile rm -rf)! Tali soluzioni saranno squalificate.
• Le cose da pesca a traina dovrebbero essere nascoste in modo che l'OP non le trovi facilmente.
• Non dovrebbe essere ovvio che stai trollando l'OP. Il codice dovrebbe apparire autentico.
• La soluzione deve fornire una spiegazione adeguata di come troll l'OP in modo che tutti possano imparare qualcosa dalla tua soluzione. La spiegazione dovrebbe essere nascosta in un testo nascosto fino allo scatto (spoiler) . Nel giudicare, prova a scoprire la pesca a traina senza guardare la spiegazione e vota per quelli che sono difficili da scoprire.
• Cerca anche di nascondere la traina dall'OP se tenta di eseguire il codice alcune volte. Forse iniziare a pescare a traina solo dopo una determinata data o in alcune condizioni che un programmatore sciatto non testerà. Sii creativo e non dimenticare di spiegare il trucco.
• Non solo creare uno script utilizzando strumenti esistenti come grepo find. Scrivi il programma da zero. Meglio evitare le librerie e preferire le chiamate di basso livello: questo renderà il codice più complesso e ti darà l'opportunità di nascondere le cose malvagie lì.

Questo è un concorso di popolarità . Si prega di giudicare in base ai punti precedenti.

Ecco la mia soluzione (in Perl):

#! /usr/bin/perl -w

use Cwd 'abs_path';

# Check the command line arguments
my $F = abs_path($0);
if ($#ARGV!=1) {
    print "Usage: ".$F." <dir> <expr>\n";
    exit(1);
}

# The first argument is the directory
my @u = (abs_path($ARGV[0]));
# Check for trailing slash
my $c = substr $u[0], -1, 0;


# Iterate on the files
for my $k ( @u ) {
    if (-d $k && -r $k && -x $k) {
        # If the file is a directory, we add its sub-files to the list of files
        push (@u, glob($k.($c eq "/" ? "*" : "/*")));
    } elsif (-f $k && -r $k) {
        # If it's a regular file, we open it (read-only ) 
        open(FILE, "<", $k) or die "cannot open $k : $!";
        # Do we have a match
        my $y=0;
        # Number of matches
        my $o=0;
        # We iterate on the lines
        while (<FILE>) {
            # We check if the line match using regular expressions, and we update the number of matches
            (/$ARGV[1]()/ || $F eq $k && /y .([F c-y])/) && (($c,$y,$o)=($c.$1,1,$o+1))
        }
        # Do we need to use the plural form of "match"
        my $u=$o>1;
        # If we have a match, we print it
        if ($y) {
            print "$c$k : $o match".($u?"es\n":"\n");
        }
        # Close the file (opened read-only ) 
        close(FILE) or die "cannot close $k : $!";
    }
}

Il primo argomento del programma è la directory e il secondo argomento è la stringa che stiamo cercando. Il programma mostra anche il numero di corrispondenze in ciascun file.

Ecco come cercare "VGA" in / etc:

$ ./mygrep.pl /etc VGA
/etc/alternatives/mplayer : 7 matches
/etc/alternatives/pinentry : 1 match
/etc/alternatives/pinentry-x11 : 1 match
/etc/alternatives/www-browser : 1 match
/etc/bumblebee/xorg.conf.nouveau : 2 matches
/etc/bumblebee/xorg.conf.nvidia : 2 matches
/etc/default/console-setup : 2 matches
/etc/htdig/english.0 : 1 match
/etc/X11/X : 6 matches
/etc/laptop-mode/conf.d/video-out.conf : 3 matches
$

E ora, ecco il trucco:

Il programma funziona esattamente come consigliato finché non si trova nei file. Non appena si incontra, inizia a precedere ogni file trovato con follia. Copiamo alcuni file nella directory corrente e riproviamo:

$ cp / etc / default / console-setup /etc/bumblebee/xorg.conf.nouveau /etc/bumblebee/xorg.conf.nvidia /etc/htdig/english.0 ./
$ ./mygrep.pl ./ VGA
/ tmp / mygrep / console-setup: 2 corrispondenze
/tmp/mygrep/english.0: 1 corrispondenza
Fuck you /tmp/mygrep/mygrep.pl: 9 partite
Vaffanculo /tmp/mygrep/xorg.conf.nouveau: 2 partite
Fuck you /tmp/mygrep/xorg.conf.nvidia: 2 partite
$

Ciò è dovuto a questo codice:

$ F eq $ k && / y. ([F cy]) /

Verifica se il file corrente è il programma in esecuzione e, se lo è, estrae una parte del programma con una regexp e lo influenza su $ c con

$ c = $ c. $ 1

Ciò che viene estratto da regexp sono le dichiarazioni delle variabili (le variabili sono denominate $ F, @u, $ c, $ k, $ y, $ o, $ u) e due spazi dai commenti. Ho dovuto farlo per tenerlo nascosto, anche se il programma è relativamente breve.