Copy Link
Add to Bookmark
Report
Viaggio negli universi paralleli
//-----------------------------------------------
-= Master *** =-
Master@spippolatori.com
SPP MEMBER
www.spippolatori.com/memberspp/master
www.spippolatori.com - www.uic-spippolatori.com
//-----------------------------------------------
##########################################################################################
# #
# VIAGGIO NEGLI UNIVERSI PARALLELI #
# #
# Ovvero come provare 1000 password su un sito web in pochi secondi con #
# una misera connessione PSTN e un modem da 4 soldi. #
# [ o qualcosa di simile. :) ] #
# #
# #
##########################################################################################
Come prima cosa volevo premettere che in questo articolo parlero' di tutto fuorche' delle
cose citate nel titolo. hi hi hi
In effetti da quello che ne seguira' sara' possibile -anche- estrapolare le informazioni
per eseguire dei bruteforce in parallelo su una singola macchina ma questo lo lascio alla
perfida fantasia e alla malizia del lettori.
Premessa:
La principale differenza tra Windows e l'MS-DOS e' il fatto che il primo puo' (anche se
a fatica) eseguire contemporaneamente piu' lavori spendendo per ognuno solo una parte
della frequenza di clock del processore.
Questa occorrenza, come tutti sanno, prende il nome di multitasking. Pochi sanno invece
che nonostante l'evidente possibilita' di farlo i sistemi operativi che si basano
sull'ms-dos come windows95 o anche windows98 NON sono sistemi multitasking.
Questo vuol dire che non si possono eseguire piu' programmi contemporaneamente?
No, certo, questo vuol dire soltanto che l'impegno del processore per l'esecuzione di
programmi in parallelo e' talmente esorbitante rispetto ad un altro sistema che proponga
un multitasking reale (come ad esempio NT) che gia al terzo o al quarto programma che
gira allegramente sul nostro bel desktop anche un pentium III comincia ad elaborare alla
stessa velocita' di un Olivetti M24 appena uscito dal laboratorio dell'assistenza tecnica.
[suo naturale luogo di permanenza]
Dato che la barbara gestione del multitasking dipende piu' da una carenza strutturale
del sistema operativo che non dal volere degli utenti e' quasi sempre impossibile sperare
di vedere girare sul proprio sistema un numero elevato di programmi contando sul fatto
che questi poi sfruttino al meglio la velocita' del processore..
tranne che .. in un solo caso pratico: [meraviglia! :)) ] -> l'uso del winsock.
La rete infatti ci viene in aiuto facendoci presente un altra carenza strutturale
[la lentezza nella trasmissione e nella ricezione dei dati via tcp/ip] che pero' in
un certo senso potrebbe tornare a nostro vantaggio.
E' la prima volta nella storia che un difetto si trasforma in un pregio?
Prendiamo il caso di un portscan.
Eseguire un portscan su una serie di porte significa basilarmente:
aprire un socket, cercare una connessione con una determinata porta N, aspettare
una risposta (che in genere potrebbe arrivare anche dopo svariati secondi), verificare
la risposta o la mancanza di quest'ultima fornendo in uscita un dato rappresentativo
della situazione di quel particolar servizio e passare alla successiva valutazione
della porta N+1 ..
La cosa piu' drammatica e' rappresentata dalla frase "aspettare una risposta per
qualche secondo.." .. se mettiamo di dover aspettare anche un solo secondo per
avere la risposta (spesso ne servono anche 1o o piu'), considerando di dover
verificare anche soltanto 10.000 porte sulle 32/64000 possibili (a seconda che si
tratti di protocollo TCP o UDP) potrebbero passare ben
10.000 secondi
prima di terminare il nostro lavoro..
10.000 secondi = 166.67~ minuti = 2.77~ ore ..
un po' troppo. :))
Stesso problema volendo tentare un bruteforce di un pop o di una pagina web.
Nel caso del pop:
1 secondo per l'input dello user e relativa risposta
1 secondo per l'input della password
diciamo almeno 2 secondi per la conferma..
4 secondi in totale per la prova di una coppia di password per il login
volendo provare 10000 password (sapendo lo user) ci metteremmo appena
4*10000 secondi = 666.67~ minuti = 11.11~ ore
nel caso della pagina web andrebbe ancora peggio
mettendo un minimo di 5 secondi per la risposta si salirebbe
(sempre con 10000 tentativi) a 13.89~ ore
Il tutto sempre nell'ipotetico caso di una connessione non disturbata, senza crolli
di linea, senza vari accidenti in arrivo dalla compagnia telefonica ed altre
occorrenze rare ed eventuali che si presenterebbero puntualmente alla messa in pratica
dei lavori.
C'e' pero' una cosa da considerare e che torna a nostro completo vantaggio.. ad esempio,
nei 5 secondi durante i quali il nostro computer aspetta la risposta dal server web..
LUI ("esso"? .. io preferisco "lui" ;-) ) .. cosa fa?
La risposta e' nulla! .. ma allora se non fa nulla non potremmo usare questo
tempo per tentare un altra coppia di password ed aspettare anche da questa in parallelo
alla prima? La risposta naturale e' SI.
Il sistema (quasi)multitasking windows ci viene in aiuto permettendoci di eseguire
anche da console DOS (sempre che stiamo compilando in modalita' "win32" console dos)
piu' lavori contemporaneamente.
Potremmo per il portscan provare a verificare lo stato di 1000 porte contemporaneamente
o per il bruteforce del pop o del sito web (o ftp) verificare un migliaio di coppie
di passwords per il login tutte insieme e (aspettata la risposta) passare altre
mille.
C'e' da considerare un tempo tecnico di qualche secondo necessario alla macchina per
poter attivare da programma tutto l'ambaradan ma in generale sono possibili situazioni
per le quali si possono effettuare scanning di 300 porte alla volta spendendo una media
di 10/12 secondi .. e quindi verificare tutte e 10.000 le nostre porte dell'esempio
iniziale in circa 33 secondi a fronte delle quasi tre ore iniziali..
oppure fare la stessa cosa con il login del pop e del server web impiegando solo pochi
minuti invece della mezza giornata necessaria nel caso della verifica -lineare-.
Come si fa tutto questo?
Si fa con una semplice istruzione _beginthread [ CreateThread, CreateProcess, ecc.. ]
[ salto di proposito una ulteriore pappardella sui socket asincroni in merito ai quali
ho gia' dettagliato in precedenti articoli "winsock per cerebrolesi", "winsock tutorial",
ecc... ]
In pratica un thread e' un processo (un programma.. una procedura..) che viene eseguito
all'interno di un altro processo padre e del quale ne diventa ovviamente il figlio
legittimo.
Un po' come i messaggi su un newsgroup tanto per rendere l'idea.
Un "processo" e' un nuovo messaggio che viene postato sul news server, e un thread e
anch'esso un nuovo processo ma viene inserito all'interno di un altro messaggio
preesistente in risposta a (o a seguito di) questo.
Il vantaggio del thread (nel nostro caso) consiste nel fatto che segando il processo
padre (il nostro programma che aprira' tutti i thread) si segheranno dalla memoria
anche tutti i suoi figli senza doversi preoccupare troppo di terminarli.
Non c'e' virtualmente limite al numero di thread che possono essere aperti all'interno
di un nostro programma se non le limitazioni di memoria e di velocita' della macchina.
[ cosa non vera per i socket windows pero' .. oltre i 300 l'impegno del kernel diventa
tale da mandare in palla anche il sistema piu' ben equipaggiato ]
Sostanzialmente le due Api _beginThread e CreateThread necessarie all'apertura di
un nuovo processo figlio sono equivalenti ..
_beginthread pero' e' piu' facile da usare perche' richiede meno parametri
[ anche se una briciola in piu' di attenzione ]
Comunemente si preferisce CreateThread.. questo in particolare e' vero per gli
utilizzatori del Visual C++. ;-)
perche'?
<mode CATTIVERIA ON>
...
Semplice.. perche' _beginthread non ce l'hanno! :)) .. ovvero ce l'hanno ma non
sanno di avercelo. :))
...
<mode CATTIVERIA OFF>
Differentemente dal Borland che compila sempre in modalita' MultiThread (almeno il
Builder) sul Visual C questa stessa modalita' deve essere settata nelle proprieta' di
progetto altrimenti il compiler andando a pescare le proprie funzioni nelle librerie
Run Time specifiche per i singoli oggetti non riuscira' a trovare quello che ci serve.
Per Far si che anche il Visual C compili correttamente _beginthread bastera' entrare
nelle opzioni di progetto
Project / Setting / C++
Selezionare nella combo Category / Code Generation
e poi nella combo Use Run-Time Library / Multithreaded
Oppure, piu' semplicemente, andare nel file *.mak generato dal nostro progetto e la dove
troviamo come parametri ed argomenti del compilatore
... /nologo /ML /W3 /Gm /GX /Zi /Od / ....
sostituire a /ML -> /MT
..
Come si usa?
La sintassi e' semplice e la si ricava dall'header process.h
_beginthread
_CRTIMP unsigned long __cdecl _beginthread (
void (__cdecl *) (void *),
unsigned,
void *
);
in pratica tre soli parametri. Il secondo non serve a nulla. :)) [o quasi]
Il primo parametro e' la procedura che vogliamo far eseguire come processo "parallelo"
l terzo parametro sono gli argomenti della stessa procedura.
..nasce qui un piccolo problema .. di base e' possibile passare come argomento un solo
parametro in formato
void *
ovviamente riconvertibile al volo in quello che vogliamo tramite casting
ma per passare pero' piu' argomenti di formato diverso sara' necessario passare il
puntatore ad una struttura che li contenga.
per questo rimando alla lettura della mia faq personale sui problemi della compilazione
col c++ e sulla gestione del winsock che potete trovare sulla mia pagina
www.spippolatori.com/memberspp/master
# ∞ #
Primo esempio banale di _beginthread
Tempo fa avevo fatto un piccolo programma dimostrativo che faceva scorrere delle
scritte a video.
Mi era venuto voglia di aggiungerci una qualche musichetta di sottofondo e allora
ho pensato di sfruttare _beginthread
Ho allora convertito in forma numerica il mio vecchio programma scorre.exe
[contenente il visualizzatore a schermo compilato col Turbo c++ e quindi velocissimo]
->scorre.h
un file midi da far suonare tramite le apposite funzioni MCI
-> A.h
e un file PIF che mi massimizzasse la console dos contenente il demo scorre.
PIF.h
[ per avere tutti i sorgenti guardare l'acclusa directory supporti/demo ]
ho poi provato ad usare sia CreateThread che -beginthread
(piu' che altro per farvi vedere solo le diverse sintassi)
con questo risultato
------------------------------------------------------------- suona3.cpp
#include<windows.h>
#include<stdio.h>
#include<process.h>
#include<mmsystem.h>
#include<dos.h>
#include<conio.h>
#include "pif.h"
#include "scorre.h"
#include "a.h"
void suona(void *);
main()
{
int a;
LPDWORD tID;
FILE *f;
f = fopen("scorre.pif", "wb");
for (a = 0; a < 967; a++)
{
putc(pif[a], f);
}
fclose(f);
f = fopen("scorre.exe", "wb");
for (a = 0; a < 11760; a++)
{
putc(scorre[a], f);
}
fclose(f);
f = fopen("a.mid", "wb");
for (a = 0; a < 35125; a++)
{
putc(mus[a], f);
}
fclose(f);
//CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)suona, NULL, 0, (LPDWORD)&tID);
_beginthread(suona,0,0);
mciSendString("close mymid", NULL, NULL, NULL);
mciSendString("open a.mid type sequencer alias mymid", NULL, NULL, NULL);
mciSendString("play mymid from 1", NULL, NULL, NULL);
printf("Demo 1.1 (c)2K Master <Master@spippolatori.com>\n"
" http://www.spippolatori.com/memberspp/master\n\n"
" ___ ___ ___ \n"
" /\\__\\ /\\ \\ /\\ \\ \n"
" /x/ _/_ /xx\\ \\ /xx\\ \\ \n"
" /x/ /\\ \\ /x/\\x\\__\\ /x/\\x\\__\\ \n"
" /x/ /xx\\ \\ /x/ /x/ / /x/ /x/ / \n"
" /x/_/x/\\x\\__\\ /x/_/x/ / /x/_/x/ / \n"
" \\x\\/x/ /x/ / \\x\\/x/ / \\x\\/x/ / \n"
" \\xx/ /x/ / \\xx/__/ \\xx/__/ \n"
" \\/ /x/ / __ \\x\\ \\ __ \\x\\ \\ __ \n"
" /x/ / /\\_\\ \\x\\__\\ /\\_\\ \\x\\__\\ /\\_\\ \n"
" \\/__/ \\/_/ \\/__/ \\/_/ \\/__/ \\/_/ \n\n");
printf(" Server web -> http://www.spippolatori.com http://spippolatori.cjb.net\n");
printf(" . Hacking Etico: Sicurezza, Programmazione, Tutorial. [no warez/lamerz]\n\n");
printf(" Server web -> http://www.uic-spippolatori.com\n");
printf(" [U.I.C. Universita' Italiana del Cracking]\n");
printf(" . Cracking Etico: Reverse engineering, Asm coding. [no crackz]\n\n");
printf(" Server news -> news://news.shy.datawell.it\n");
getch();
remove("a.mid");
remove("scorre.exe");
remove("scorre.pif");
return 0;
}
void suona(void *)
{
HANDLE j;
char s[0xff];
GetCurrentDirectory(255,s);
strcat(s,"\\scorre.exe");
ShellExecute(j, 0, s, NULL, NULL, SW_NORMAL);
}
------------------------------------------------------------- suona3.cpp
come e' facile vedere il programma inizia ricreandosi
1. il programma scorre. [il compilato in turbo c che esegue l'animazione a video]
2. il file pif necessario a massimizzare il programma scorre
3. il file a.mid
continua poi creandosi un thread per l'esecuzione di scorre.exe
usando
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)suona, NULL, 0, (LPDWORD)&tID);
oppure
_beginthread(suona,0,0);
il primo parametro richiama la procedura "suona" che contiene il recupero e
la chiamata vera e propria al programma scorre
void suona(void *)
{
HANDLE j;
char s[0xff];
GetCurrentDirectory(255,s);
strcat(s,"\\scorre.exe");
ShellExecute(j, 0, s, NULL, NULL, SW_NORMAL); // -<
}
il tutto da un piacevole effetto scenografico.
Si vede apparire uno schermo dos con una animazione di caratteri e si sente una
musichetta di sottofondo. Alla pressione di un tasto il thread con il programma
d'animazione in turbo C viene terminato ma permane la musichetta con in sottofondo
un altra consolle dos (quella del programma padre) contenente informazioni sullo
spp group.
Si deduce da questo semplice esempio che usare -beginthread e' veramente banale.
basta costruirsi una funzione con dentro il sottoprogramma da far eseguire in
modalita' parallela e semplicemente passarlo a _bginthread che si occupera' di
fare tutto il lavoro per noi.
# ∞ #
Vediamo allora come primo -vero- esempio come sia possibile costruirsi un
portscan multithread ( e quindi utile per monitorare allo stesso tempo N
porte o eseguire lo scanning di piu' porte su piu' server diversi
contemporaneamente .. e tutto con pochissime righe di c++)
Prendiamo in esame un semplice portscan lineare che avevo pubblicato in passato
su un altro articolo (non ricordo quale. :)) )
la procedura per eseguire lo scan e' tutta qui.
---------------------------- Procedura base del portscan
int ScanPort(char *ip, int inizio, int fine) {
struct sockaddr_in dati;
struct hostent *hp;
int sock,n;
hp=gethostbyname(ip);
if(hp==NULL){
printf("Non rieco a risolvere l'indirizzo %s!\r\n",ip);
exit(0);}
printf("Eseguo la scansione delle porte.\n");
for (n=inizio;n<=fine;++n) {
if (!(sock = socket(AF_INET, SOCK_STREAM, 0))){
printf("Errore: Impossibile connettersi.\n");return -1;}
dati.sin_family = AF_INET;
dati.sin_addr.s_addr = ((struct in_addr *)(hp->h_addr))->s_addr;
dati.sin_port = htons(n);
if(connect(sock, (struct sockaddr*)&dati,sizeof(dati))!=-1)
printf("%s : %d\n",ip,n);
closesocket(sock);
}
printf("\n");return -1;}
---------------------------- Procedura base del portscan
.. in pratica si connette all'indirizzo prefissato ed esegue da
porta <inizio> a porta <fine> un controllo sulla apertura delle medesime.
per chiamarla e' sufficiente scrivere
ScanPort("NOME DEL SERVER",PORTA_INIZIALE,PORTA_FINALE);
con un programma minimo tipo questo:
--------------------------------------------- portscan.cpp
#include <stdio.h>
#include <winsock2.h>
#include <conio.h>
#include <process.h>
char a1[0xff];
int a2,a3;
int ScanPort(char *ip, int inizio, int fine) {
struct sockaddr_in dati;
struct hostent *hp;
int sock,n;
hp=gethostbyname(ip);
if(hp==NULL){
printf("Non rieco a risolvere l'indirizzo %s!\r\n",ip);
exit(0);}
printf("Eseguo la scansione delle porte.\n");
for (n=inizio;n<=fine;++n) {
if (!(sock = socket(AF_INET, SOCK_STREAM, 0))){
printf("Errore: Impossibile connettersi.\n");return -1;}
dati.sin_family = AF_INET;
dati.sin_addr.s_addr = ((struct in_addr *)(hp->h_addr))->s_addr;
dati.sin_port = htons(n);
if(connect(sock, (struct sockaddr*)&dati,sizeof(dati))!=-1)
printf("%s : %d\n",ip,n);
closesocket(sock);
}
printf("\n");return -1;}
void main(int argc, char *argv[]) {
WORD wVersionRequested;
WSADATA wsaData;
int y;
wVersionRequested=MAKEWORD(2,0);
y=WSAStartup(wVersionRequested,&wsaData);
//--------------------------------------------------------
ScanPort("NOME DEL SERVER",PORTA_INIZIALE,PORTA_FINALE);
//--------------------------------------------------------
cprintf("Fine\r\n");getch();
WSACleanup();exit(0);
}
--------------------------------------------- portscan.cpp
# ∞ #
vediamo ora come implementare lo stesso programma con _beginthread
Esempio:
-------------------------------------------- SUPERPORTSCAN.CPP
#include <stdio.h>
#include <process.h>
#include <winsock2.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
void ScanPort(void *passa)
{
char ip[0xff];
char *fg;
int inizio, fine;
struct sockaddr_in dati;
struct hostent *hp;
int sock, n, tipo;
char a1[0xff], a2[0xff];
fg = (char *)passa;
strcpy(ip, strtok(strdup(fg), "#"));
strcpy(a1, strtok(strrev(strtok(strrev(strdup(fg)), "#")), ":"));
strcpy(a2, strrev(strtok(strrev(strdup(fg)), ":")));
inizio = atoi(a1);
fine = atoi(a2);
tipo = (int)inet_addr(ip);
printf("scandisco %s %d %d [%d]\n", ip, inizio, fine, tipo);
if (tipo < 0)
{
hp = gethostbyname(ip);
if (hp == NULL)
{
printf("Non riesco a risolvere l'indirizzo %s!\r\n", ip);
return;
}
}
for (n = inizio; n <= fine; ++n)
{
if (!(sock = socket(AF_INET, SOCK_STREAM, 0)))
{
printf("Errore: Impossibile connettersi.\n"); exit(0);
}
dati.sin_family = AF_INET;
if (tipo < 0)
{
dati.sin_addr.s_addr = ((struct in_addr *)(hp->h_addr))->s_addr;
}
else
{
dati.sin_addr.s_addr = inet_addr(ip);
}
dati.sin_port = htons(n);
if (connect(sock, (struct sockaddr *)&dati, sizeof(dati)) != -1)
{
printf("#. Trovato -> %s : %d\n", ip, n);
}
closesocket(sock);
}
printf("\n");
}
void main(int argc, char *argv[])
{
int y;
WORD wVersionRequested;
WSADATA wsaData;
char ss[0xff];
char s1[0xff][0xff];
int k = 0;
FILE *f;
wVersionRequested = MAKEWORD(2, 0);
y = WSAStartup(wVersionRequested, &wsaData);
f = fopen("lista.txt", "rb");
while (!feof(f) && (fgets(s1[k], 255, f) != NULL))
{
s1[k][strlen(s1[k])-2] = 0;
printf("<%s>\n", s1[k]);
_beginthread(ScanPort, 0, s1[k++]);
}
fclose(f);
cprintf("Fine. Attendere per il controllo.\r\n");
getch();
WSACleanup();
exit(0);
}
-------------------------------------------- SUPERPORTSCAN.CPP
Vediamo come funziona SUPERPORSCAN
Innanzitutto ho pensato a come fornire al programma i vari server da
controllare.
La cosa migliore era quella di crearsi un file di testo [LISTA.TXT] contenente
le specifiche con questo formato
<NOME_DEL_SERVER>#<PORTA_INIZIALE>:<PORTA_FINALE>
i server dichiarati su ogni riga verranno controllati tutti in parallelo
[ i ranges di porte sono controllati linearmente]
e quindi per verificare in parallelo i server
www.pippo.it dalla porta 2 alla porta 6
194.184.55.5 dalla porta 4 alla porta 9
e
www.spippolatori.com dalla porta 70 alla porta 80
dovremo decidere se elaborare in multithread solo i tre scan relativi ad ogni server
o addirittura tutti gli scan per ogni server e per ogni porta in parallelo.
Nel primo caso scriveremo il file
----------------------------------- lista.txt
www.pippo.it#2:6
194.184.55.5#4:9
www.spippolatori.com#70:80
----------------------------------- lista.txt
per il secondo dovremo invece scrivere
----------------------------------- lista.txt
www.pippo.it#2:2
www.pippo.it#3:3
www.pippo.it#4:4
www.pippo.it#5:5
www.pippo.it#6:6
194.184.55.5#4:4
194.184.55.5#5:5
194.184.55.5#6:6
194.184.55.5#7:7
194.184.55.5#8:8
194.184.55.5#9:9
www.spippolatori.com#70:70
www.spippolatori.com#71:71
www.spippolatori.com#72:72
www.spippolatori.com#73:73
www.spippolatori.com#74:74
www.spippolatori.com#75:75
www.spippolatori.com#76:76
www.spippolatori.com#77:77
www.spippolatori.com#78:78
www.spippolatori.com#79:79
www.spippolatori.com#80:80
----------------------------------- lista.txt
ovvero nel primo caso il programma SUPERPORTSCAN
si apre 3 diversi thread..
nel primo controlla -linearmente- le porte da 2 a 6 di www.pippo.it
nel secondo controlla -linearmente- e in parallelo allo scanning di www.pippoit
le porte da 4 a 9 dell'indirizzo ip 194.184.55.5
e nel terzo stesso lavoro per le porte da 70 a 80 di www.spippolatori.com
nel secondo file lista.txt viene dichiarato che superportscan deve eseguire
i controlli su tutti e tre i server e per ogni porta con thread a parte..
il programma quindi si aprira' 23 thread diversi ed eseguira' tutto nel
giro di pochissimi secondi.
Simpatico no!? ;-)
..................................................................................
Nota di programma: [ FORMATO GENERICO IN INPUT DEGLI HOSTS ]
..................................................................................
per l'input del server da verificare ho modificato la procedura iniziale dando
la possibilita' di inserire sia gli ip in formato numerico che il loro
resolve letterale.
La funzione inet_addr(ip) oltre che convertire un ip da formato numerico puntato
in formato network serve -anche- per capire se l'ip fornito in pasto
al programma e' appunto in formato numerico o no grazie al valore di ritorno.
Dichiarando la variabile "tipo" = (int)inet_addr(ip);
quest'ultima prendera' un valore negativo se l'ip fornito non sara'
"aaa.bbb.ccc.ddd."
ed e' quindi logico presupporre che l'ip sia stato dichiarato col suo resolve letterale
es: "www.pippo.com"
quindi
if (tipo < 0) // cioe' se e' stato fornito l'ip in formato letterale
{
hp = gethostbyname(ip); // trova l'ip in formato numerico
if (hp == NULL)
{
printf("Non riesco a risolvere l'indirizzo %s!\r\n", ip);
return;
}
}
...
if (tipo < 0)
{
// l'ip fornito era letterale quindi inserisce l'indirizzo numerico
// in formato network dal valore recuperato dal precedente
// getostbyname(ip)
dati.sin_addr.s_addr = ((struct in_addr *)(hp->h_addr))->s_addr;
}
else
{
// altrimenti l'ip fornito era in formato numerico, quindi lo
// converte semplicemente in formato network tramite inet_addr
// e lo inserisce nella struttura dei parametri di connessione
dati.sin_addr.s_addr = inet_addr(ip);
}
..................................................................................
# ∞ #
Un altro esempio:
Vogliamo risolvere contemporaneamente tutti gli indirizzi di una classe c
[fare quello che si chiama in gergo "reverselookup" ] ?
Cominciamo con un programma lineare che risolva fli indirizzi ad uno ad uno.
[il tempo medio necessario a risolvere tutti e 255 [se esistenti] di una classe
C potrebbe variare da pochi minuti a una mezzora.
--------------------------------------------------- SITESCAN.CPP
#include <windows.h>
#include <winsock.h>
#include <stdio.h>
#include <string.h>
void vedi(char *ip);
void main(int nf, char **file)
{
int n;
char s[0xff];
WSADATA ws;
int nRet;
nRet = WSAStartup(0x0101, &ws );
for(n=atoi(file[2]);n<=atoi(file[3]);n++)
{
sprintf(s,"%s.%d",file[1],n);
vedi(s);
}
WSACleanup();
}
void vedi(char *ip)
{
LPHOSTENT h;
struct in_addr ind;
ind.s_addr = inet_addr(ip);
if (ind.s_addr == INADDR_NONE) h = gethostbyname(ip);
else h = gethostbyaddr((const char *)&ind,sizeof(struct in_addr), AF_INET);
if (h == NULL) return;
printf("[%s] -> %s\n", ip,h->h_name);
}
--------------------------------------------------- SITESCAN.CPP
sintassi: SITESCAN 194.184.55 1 255
risolve tutti gli indirizzi da 194.184.55.1 a 194.184.55.255
ovviamente SITESCAN aaa.bbb.ccc 30 68
risolvera' tutti gli indirizzi da aaa.bbb.ccc.30 a aaa.bbb.ccc.68
(194.184.55.xxx e' la mia rete .. se provate a risolvere gli indirizzi da 20 a 60
vedrete il perche' del mio precedente programma per trovare il -nome dei nani- :)) )
Facciamone una versione che risolva tutti gli indirizzi in un colpo solo. :))
Ovvero come risolvere 255 indirizzi diversi in 3/4 secondi.
--------------------------------------------------- sitescanMT.CPP
#include <winsock2.h>
#include <process.h>
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <stdlib.h>
void vedi(void *ip);
int conta=0;
void main(int nf, char **file)
{
int n;
char s[0xff];
char g[0xff+2][32];
WSADATA ws;
int inizio,fine;
for(n=1;n<=255;n++)
{
itoa(n,s,10);
sprintf(g[n],"%s.%s",file[1],s);
}
inizio = WSAStartup(0x0101, &ws );
inizio=1;fine=255;
if(nf==3)inizio=atoi(file[2]);
if(nf==4){inizio=atoi(file[2]);fine=atoi(file[3]);}
for(n=inizio;n<=fine;n++) _beginthread(vedi, 0, g[n]);
getch();
WSACleanup();
}
void vedi(void *ip)
{
LPHOSTENT h;
struct in_addr ind;
ind.s_addr = inet_addr((char *)ip);
h = gethostbyaddr((const char *)&ind,sizeof(struct in_addr), AF_INET);
if (h == NULL){conta++;return;}
printf("[%s] -> %s\n", ip,h->h_name);
conta++;
}
--------------------------------------------------- sitescanMT.CPP
con sitescanMT 194.184.55 1 255
eseguiremo lo stesso lavoro del programma precedente ma alla velocita' del fulmine. :))
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
ATTENZIONE!!
I providers si troveranno ad avere un bella parte di banda occupata da queste metodologie
e quindi saranno soliti a preoccuparsi e/o innervosirsi.
Fate mente locale al fatto che e' come se 255 persone si collegassero tutte insieme ad
altrettanti indirizzi diversi e tutti sullo stesso provider.
Ripetendo operazioni simili anche da poche macchine diverse ma tutte sullo stesso
disgraziato sarebbe possibile mandare in palla totale un qualsiasi servizio.
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Per inciso nei supporti allegati ho anche messo un progetto per il Borland C++
Builder contenente lo stesso programma con una piu' amichevole interfaccina
windows.
Questo tanto per mostrare come le stesse metodologie siano utilizzabili
anche tramite applicazioni windows e senza usare socket asincroni o
Active-x particolari.
Vedere -> SCANSATI :)) [da ScanSiti il passo e' breve. ]
e questo e' tutto.
ah... dimenticavo...
Avrei voluto aggiungere anche l'altro supporto che avevo preparato espressamente
per questo articolo.
Un bruteforce velocissimo in Multithread.. ma poi mi sono detto:
E' ILLEGALE!! :)) he he
Se volete fare delle prove pero' vi consiglio discaricarvi il mio Elzapop..
il bruteforce in multithread l'ho ottenuto da quello modificando solo una
paio di righe ed aggiungendo _beginthread al posto giusto...
...a buon intenditor. ;-)
Auguri. ;-)
##########################################################################################
//-----------------------------------------------
-= Master *** =-
Master@spippolatori.com
SPP MEMBER
www.spippolatori.com/memberspp/master
www.spippolatori.com - www.uic-spippolatori.com
//-----------------------------------------------
