Domanda Spoofing

[lello83]

Salve a tutti, volevo chiedervi a voi del forum, come posso fare lo spoofing, so che serve a far credere a terzi di essere un altro (clonando ip, clonando e-mail, ecc).

Volevo chiedervi come si fà? con quale software?

 

[pop3]

Riferimento: Spoofing

quello che dici tu e molto complicato,solo pochi esperti riescono a farlo,e non c'e un software per farlo!il promotore di questa cosa e kevin mitnick,ho notato che sei fissato con l'hacking e fai riechieste un po assurde,questo e un forum per giovani ragazzi appassionati di pc ma nessuno di noi può aiutarti su questo argomento,inoltre ti volevo dire che perdi tempo a richiedere crypter e backdoor free fud,rompo subito la tua illussione dicendoti che non ci sono crypter e backdoor free fud,e non esistono crack per le backdoor se le vuoi usare te la devi comprare!

 

[lello83]

Riferimento: Spoofing

quello che dici tu e molto complicato,solo pochi esperti riescono a farlo,e non c'e un software per farlo!il promotore di questa cosa e kevin mitnick,ho notato che sei fissato con l'hacking e fai riechieste un po assurde,questo e un forum per giovani ragazzi appassionati di pc ma nessuno di noi può aiutarti su questo argomento

Scusami, io credevo di parlare nella sezione Hacking, e non sezione appassionati di PC, se non sei in grado di aiutarmi per cortesia taci che non sei di nessun aiuto.

inoltre ti volevo dire che perdi tempo a richiedere crypter e backdoor free fud,rompo subito la tua illussione dicendoti che non ci sono crypter e backdoor free fud,e non esistono crack per le backdoor se le vuoi usare te la devi comprare!

Per quanto riguarda crypter e backdoor free fud, è un mio vecchio 3d, se mi volevi dare questo consiglio potevi farlo nell'altro 3d ;) Thanks

 

[pop3]

Riferimento: Spoofing

forse mi sono espresso male,la mia non era una critica,volevo solo dirti che quella tecnica da te citata e di altissimo livello,kevin mitnick e stato ad usarla per primo quindi pensa a che livelli devi essere per farlo!dicevo che in questo forum ci sono ragazzi e credimi nessuno e in grado,anche perche uno in grado di fare una cosa simile non credo che starebbe dietro un forum,non credi?

 

[noman88]

Riferimento: Spoofing

Lo spoofing "semplice" non si fa clonando ip ecc...Scarica wireshark e leggi qualche guida.Mi raccomando,devi trovare reti pubbliche,se no riuscirai soltanto a scoprire la pass della email dei tuoi genitori ^^.

 

[Rat445]

l protocollo TCP/IP, dalla sua comparsa ad oggi, e' stato analizzato dal punto di vista della sicurezza, delle performance, dell'ottimizzazione e degli stati indefiniti in maniera molto profonda. Nel corso del tempo varie vulnerabilita' sono state scoperte, sia nel protocollo in se', che nelle varie implementazioni disponibili (ossia gli stack TCP/IP dei sistemi operativi). Tuttavia, una implementazione ben pensata del TCP/IP, e' ancora in grado di fornire buoni livelli di sicurezza nel caso in cui siano state prese tutte le precauzioni necessarie.

****L'IP spoofing attack*****

Per chi si avvicina al mondo della sicurezza, l'attacco conosciuto come "IP spoofing" e' spesso fonte di confusione. L'equivoco sta nel fatto che col termine "IP spoofing" si indicano due attacchi distinti: il primo consiste nello spedire dei pacchetti IP aventi l'indirizzo sorgente contraffatto, l'altro nell'utilizzo del primo attacco per costruirne uno piu' complesso, conosciuto come "blind spoofing", ovvero spoofing alla cieca. Qui vedremo in dettaglio il primo dei due attacchi.
L'IP spoofing e' una tecnica che consiste nell'inviare dei pacchetti
opportunamente 'modificati' per far credere al destinatario, che gli stessi arrivino da tutt'altra parte e, quindi, per rendersi 'anonimi' (o meglio spacciarsi per qualcun altro) agli occhi della "vittima". Questo si ottiene modificando l'indirizzo IP sorgente(source IP) nell' header (intestazione) del pacchetto (datagramma IP). L'IP spoofing viene utilizzato per molti attacchi sia di tipo D.o.S. (Denial of Service, attacchi che possono mettere fuori uso, bloccare o rallentare il sistema momentaneamente... fastidioso ma non provoca danni gravi), sia per il tipico Hacking (attacchi molto piu' interessanti che possono permettere di guadagnare particolari accessi nei sistemi) e utilizzato sia in modo diretto (attaccando cioe' direttamente il sistema che riceve i pacchetti spoofati), sia in modo indiretto (sfruttando cioe' le risposte che la macchina destinataria dello spoof invia al presunto mittente). Gli attacchi D.o.S. che si possono realizzare cmq sono molti: dai vari flood (syn flood, rst flood) al click, al boink ecc. Oppure, se proprio si vuole avere la comunicazione bilaterale, si potrebbe tentare di instaurarla alla ceca, cercando di prevedere le varie risposte della vittima ai nostri pacchetti, e rispondendo a nostra volta in modo adeguato (assicurandoci pero' che l'IP da noi spoofato sia in quel momento irraggiungibile e non possa quindi rispondere anche lui alla vittima (che, sta inviando pacchetti all'indirizzo da noi spoofato).
Uno schemino chiaro che riassume l'IP spoofing (e si trova su praticamente tutti i documenti che trattano IP spoofing), e' all'incirca questo:

host A <---------------->X<--------------> host B
|
host S ---------------->/


in cui: noi siamo host S, il bersaglio del nostro attacco e' host B e il e l'indirizzo sorgente che metteremo nell'header dei pacchetti al posto del nostro, corrisponde al'indirizzo di host A. Come si puo' realizzare lo spoofing? Be' per farvi un idea, un programma che lo realizza e che probabilmente avrete utilizzato qualche volta e' il famoso Click della 7th sphere... che fa esattamente questo: Ipotizziamo un tipico attacco D.o.S. da lamer in IRC. Secondo lo schemino che c'e' li sopra: se noi siamo host S e vogliamo disconnettere host B dal server IRC host A (un server a caso irc.tin.it hihihi) che facciamo? Impostiamo il Click con i giusti dati e scegliamo tra il modo client side oppure server side, quindi lanciamo l'attacco. Mettiamo di aver scelto l'attacco client side....
Succede che il Click comincia a mandare a host B pacchetti ICMP spoofati aventi come indirizzo sorgente host A (server IRC) e come contenuto una frase del tipo "Sono Esploso!!". ("host unreachable") Host B (vittima) a questo punto riceve questa 'lettera/pacchetto' proveniente da Host A (server IRC), legge il messaggio e realizza che host A (server IRC) e' esploso .. quindi pensa: "che cavolo ci rimango connesso a fare a un indirizzo di server che non c'e' piu' perche' e' esploso?" a questo punto si disconnette. L'attacco e' realizzato, host B e' disconnesso da IRC. Nel caso avessimo scelto il modo di attacco server side, il procedimento e' uguale ma i pacchetti vengono mandati a host A (server IRC) e provenienti da host B (vittima), quindi e' il server IRC che scollega host B credendolo 'esploso'. Questo e' solo un esempio di attacco. In effetti, sfruttare appieno l'IP spoofing (anche per cercare di far qualcosa
in piu' dei tipici D.o.S.), significa soprattutto potersi costruire i pacchetti da inviare, su misura.. a seconda del tipo di attacco che vogliamo realizzare. Questo risulta piu' facile da ottenere ad esempio su sistemi Linux che su Winzozz 9x, pero' per questi ultimi potreste utilizzare programmi appositi (ad esempio exploit generator) che funzionano abbastanza bene.

Come si fa a mandare un pacchetto spoofato?

Beh, ci sono modi e modi. Da Unix & Company e' molto facile: basta creare un socket RAW (un socket *molto* grezzo) e lavorarlo mettendoci sopra degli header IP e TCP (ma anche UDP o ICMP) non standard, cioe' come quelli che si trovano nelle librerie net*. Infatti, nel nostro header IP dovremmo mettere anche l'ip del mittente, cosa che invece con le normali funzioni di sending viene automaticamente fatta dal protocollo usato.
In principio si crea un bell'header ip tipo:

struct ipheader {
unsigned char verlen, tos; //versione+lunghezza header, tipo
unsigned short lenght, identification, flageoffset; //lunghezza, id, flags+offset
unsigned char ttl, protocol; //time to live, protocollo utilizzato
unsigned long int source, destination; //indirizzo ip sorgente, destinazione
};

ecco, bello vero?
Se esaminate attentamente vedrete:

* un char (8 bit) che include sia la versione ip che la lunghezza dello header (contenitori a 4 bit non li so trovare io in c...)

* un char (8 bit) per il tipo di servizio (TOS)

* uno short (16 bit) per la lunghezza, uno per l'identificazione e uno che include i 3 bit dei flag e i 13 del fragment offset

* un altro char per il time to live, ovvero su quanti server pu• passare prima di fermarsi

* un altro char che identifica il protocollo

* due long (32 bit) che identificano l'ip sorgente e quello di destinazione

Per agevolarci ora creeremo uno pseudo ip header:

struct pseudoipheader {
unsigned long int source, destination;
char byte_zero, protocol;
unsigned short TCP_UDP_lenght;
};

qui abbiamo l'ip sorgente, destinazione, il byte zero, il protocollo
utilizzato e la lunghezza del tcp o dell'udp.
Ora veniamo ai protocolli TCP e UDP:

struct tcpheader {
unsigned short source, destination;
unsigned long int seq, ack;
unsigned short offset_flags, window, checksum, urgent;
};

da notare che i source e i destination sono non degli indirizzi, ma delle porte (short a 16 bit), qui dovete mettere la porta sorgente e quella destinazione, insomma. Poi c'e' il SEQ e l'ACK, interi a 32 bit, e infine abbiamo l'header lenght + reserved + flags, window, il checksum e l'urgent pointer. Ecco qui anche quello dell'udp, giusto per facilitarvi la vita

struct udpheader {
unsigned short source, destination, lenght, checksum;
}
Tutto chiaro no? E per finire si crea uno struct di scambio di dati spoofati, anche questo per facilitarci la vita...

struct spdataexchange {
int fd;
char *data;
int datalen;
char *source;
unsigned short sourceport;
char *destination;
unsigned short destinationport;
unsigned long seq, ack;
unsigned short flags;
char *buffer;
int ip_optlen, tcp_optlen;
} In questo struct copieremo i dati ip e tcp e tutto il resto, per poi scriverlo sul pacchetto da inviare... Ora, come facciamo ad inviare un pacchetto??? Creeremo una funzione detta sendsppacket:

void sendsppacket(struc spdataexchange *sp, unsigned char protcollo)
{
int sp_status;
struct sockaddr_in *sp_serv;
struct hostent *sp_help;
int HEADER_BASE;
bzero((char *)&sp_serv, sizeof(struct sockaddr));
sp_serv.sin_family = AF_INET;
sp_serv.sin_addr.s_addr = inet_addr(sp->destination);
if(sp_serv.sin_addr.s_addr==(unsigned int)-1)
{
if(!(sp_help=gethostbyname(sp->destination)))
fprintf(stderr,"unknown host %sn",sp->destination), exit(1);
bcopy(sp_help->h_addr,(caddr_t)&sp_serv.sin_addr,sp_help->h_lenght);
}
switch(protocollo)
{
case TCP: HEADER_BASE = TCP_HEADER_BASE; break; //Spiego sotto questi passaggi
case UDP: HEADER_BASE = UDP_HEADER_BASE; break;
case default: exit(1); break;
}
sp_status = sendto(sp->fd, (char *)sp->buffer, sp->datalen+HEADER_BASE+
IP_HEADER_BASE+sp->ip_optlen, 0, (struct sockaddr *)&sp_serv,
sizeof(struct sockaddr));
if((sp_status < 0) || (sp_status!=sp->datalen+HEADER_BASE+IP_HEADER_BASE+sp->ip_optlen))
{
if(sp_status < 0)
perror("sendto()n"), exit(1);
printf("Trasmessi soltanto %d bytes di %dn", sp_stat, sp->datalen+HEADER_BASE+IP_HEADER_BASE+sp->ip_optlen);
}
}

Bene, con questa funzione mandiamo i pacchetti che abbiamo creato... Dopo i procedimenti di routine si tenta di risolvere l'host di destinazione, se non si riesce si esce (splendido gioco di parole...), se invece l'host esiste si copia nel "sp_serv.sin_addr". Poi si vede il protocollo: TCP e UDP ve li definite prima con #define (TCP 6 e UDP 17), se e' tcp l'header_base sara' ovviamente la lunghezza della dimensione minima dell'header tcp(20), se e' udp
quella dell'udp (8) e se e' altro esce , l'ip e' 20. Poi si manda il pacchetto spoofato realizzato prima, e si vede se il risultato e' positivo o meno, quanti bytes sono stati inviati, eccetera. La lunghezza naturalmente e' la lunghezza dei dati+l'HEADER_BASE definito prima+la lunghezza dell'header ip (20) + la lunghezza delle opzioni ip. 500 righe! Uff! Che fatica... Dovremmo esserci... Per fixare i vostri header IP e TCP, ci sono due pratiche(ALLA FACCIA!) funzioni:

void sp_fix_IP_packet(struct spdataexchange *sp, unsigned char protocollo)
{
struct ipheader *sp_help_ip;
int HEADER_BASE;
switch(protocollo)
{
case TCP: HEADER_BASE = TCP_HEADER_BASE; break;
case UDP: HEADER_BASE = UDP_HEADER_BASE; break;
case default: exit(1); break;
}
sp_help_ip = (struct ipheader *)sp->buffer;
sp_help_ip->verlen = (IP_VERSION << 4) | (IP_HEADER_BASE+sp->ip_optlen+sp->tcp_optlen);
sp_help_ip->tos = 0;
sp_help_ip->lenght = htons(IP_HEADER_BASE+HEADER_BASE+sp->ip_optlen+sp->tcp_optlen+sp->datalen);
sp_help_ip->ID = htons(12545);
sp_help_ip->flageoffset=0;
sp_help_ip->ttl = 69; //miseria! Non deve morire prima del previsto...
sp_help_ip->protocol = protocollo;
sp_help_ip->source = sp_getaddrbyname(sp->source);
sp_help_ip->destination = sp_getaddrbyname(sp->destination);
sp_help_ip->checksum = in_cksum((unsigned short *) (sp->buffer),
IP_HEADER_BASE+sp->ip_optlen);
}

Questa e' per l'ip... e' molto intuitiva, e' inutile che ve la spieghi. Attenzione, la funzione sp_getaddrbyname(char *) non ve la scrivo, ve la spiego brevemente: usate un HOSTENT, nel caso in cui l'host debba andare risolto. Se l'host e' gia' numerico, si verifica l'esistenza e si ritorna il valore long della medesima. Se invece non e' numerico, tentiamo di risolverlo e se ci riusciamo si puo' benissimo ritornare il valore long dell'host, altrimenti si da come risultato 0. Per fixare l'header TCP:

void sp_fix_TCP_packet(struct spdataexchange *sp)
{
char *pseudo_ip_construct[1500];
struct tcpheader *sp_help_tcp;
struct pseudoipheader *sp_help_pseudo_ip;
int i;
for(i=0;i<1500;i++)
pseudo_ip_construct=0;

sp_help_tcp = (struct tcpheader *) (sp->buffer+IP_HEADER_BASE+sp->ip_optlen);
sp_help_pseudo_ip = (struct pseudoipheader *) pseudo_ip_construct;

sp_help_tcp->offset_flags = htons((((TCP_HEADER_BASE+sp->tcp_optlen)/4)<<12) | sp->flags);
sp_help_tcp->seq = sp->seq;
sp_help_tcp->ack = sp->ack;
sp_help_tcp->source = htons(sp->sourceport);
sp_help_tcp->destination = htons(sp->destinationport);
sp_help_tcp->window = htons(0x7c00);

sp_help_pseudo_ip->source = sp_getaddrbyname(sp->source);
sp_help_pseudo_ip->destination = sp_getaddrbyname(sp->destination);
sp_help_pseudo_ip->zero_byte = 0;
sp_help_pseudo_ip->protocol = TCP;
sp_help_pseudo_ip->TCP_UDP_lenght = htons(sp->datalen+TCP_HEADER_BASE+sp->tcp_optlen);

memcpy(pseudo_ip_construct+12,sp_help_tcp,sp->datalen+TCP_HEADER_BASE+sp->optlen);
sp_help_tcp->checksum = in_cksum((unsigned short *)pseudo_ip_construct,
sp->datalen+12+TCP_HEADER_BASE+sp->tcp_optlen);
}


Ecco qua! Ultimo appunto: la in_cksum e' una funzione che potete trovare dappertutto, anche sul ping.c o su uno dei vari nuker... Non mi dilungo anche sull'UDP (ma questa e' discriminazione razziale! ), anche perche'‚ se conoscete bene il C (spero, altrimenti che avete fatto, avete letto fin qua senza capire un c***o???) e' molto intuitiva da realizzare... Se rimanete nel dubbio, pero', leggetevi i sorgenti di spoofit.h, una libreria che mi ha ispirato non poco. Non ricordo il nome dell'autore, un attimo... Ah, si: Bretch Claerhout.

NOTICINA: se non vi va di scrivervi gli header ip, tcp e/o udp a da soli, li potete semplicemente aggiungere queste righe all'inizio del codice

#include //contiene lo struct per lo header ip
#include //contiene quello per il tcp
#include //e quello per l'udp

ma se ve l'avessi detto prima avreste potuto comprendere come e' formato un header ip???

I pacchetti IP (il protocollo che si occupa della consegna dei datagrammi) possiedono un campo che contiene l'indirizzo sorgente ed uno che contiente l'indirizzo di destinazione. Ai fini del routing solo il secondo dei due indirizzi ha importanza. E' per questo motivo che in condizioni normali (mancanza di ACL) e' possibile spedire dei pacchetti IP che "sembrano" provenire da un qualunque IP. In altre parole, in mancanza di un protocollo di livello superiore che autentica la sorgente dei pacchetti IP, e' impossibile essere certi del fatto che l'indirizzo sorgente appartenga effettivamente all'host che li ha spediti. Immaginate un servizio di rete che utilizza il protocollo UDP per eseguire operazioni sul server su cui gira, ad esempio lo shutdown della macchina. Questo fantomatico ed insicuro protocollo (che e' assolutamente di mia fantasia, ma esempi simili si possono trovare in applicazioni reali) aspetta un pacchetto UDP contenente il comando "SHUTDOWN" da un particolare indirizzo, ammettiamo 1.2.3.4: tutti i pacchetti provenienti da altri indirizzi vengono scartati. Se non fosse possibile praticare l'IP spoofing solo l'host 1.2.3.4 sarebbe in grado di eseguire lo shutdown su quel server, di fatto invece chiunque puo' spedire un pacchetto come quello mostrato sotto.

---------------------------
| (INTESTAZIONE IP) |
| --------- ----------- |
| |1.2.3.4| - |IP SERVER| |
| --------- ----------- |
| |
|...RESTANTE IP HEADER... |
| |
| SHUTDOWN |
---------------------------

L'esempio, anche se di pura fantasia, mostra chiaramente che affidarsi ad una "trusted-relationship" che si basa sull'indirizzo IP, nel caso di protocolli non connessi, non e' affatto una buona idea. Quale sarebbe il modo corretto di disegnare il nostro shutdown-protocoll? Una delle possibilita' e' quella di cambiare il protocollo in modo che il server, invece di eseguire direttamente il comando, aspetti un pacchetto UDP contenente la stringa "AUTH". Se il pacchetto non proviene da uno degli IP autorizzati non si cura la della richiesta, alrimenti spedisce un pacchetto che contiene un numero pseudo-casuale al client e si mette in attesa di un comando. Il client dovra' rispondere con un pacchetto formato dal numero casuale che ha ricevuto dal server seguito dal comando, ad esempio "2390-SHUTDOWN". Questo protocollo ci salva dall'IP spoofing (nel caso in cui l'attacker non e' posto fisicamente tra il server ed il client, altrimenti ha la possibilita' di leggere il numero randomico e costruire il pacchetto con il comando), ma devono essere prese opportune precauzioni; il generatore dei numeri pseudocasuali deve essere "cryptographycally secure", ovvero possedendo una serie di output R1, R2, R3, RN, l'attacher non deve essere in grado di predire gli elementi successivi della sequenza (la funzione rand(3) della libc non e' un generatore sicuro, e' un generatore lineare congruenziale facilmente predicibile). La seconda condizione e' che il numero pseudo casuale sia abbastanza grande da non permettere all'attacher di montare un attacco di forza bruta in un tempo ragionevole. Come gia' detto, questo protocollo ipotizza che l'attacker, anche se non in grado di spedire pacchetti provenienti dall'indirizzo (ad esempio) 1.2.3.4, non sia in grado di intercettare le risposte che sono dirette all'host 1.2.3.4 (di solito su internet questo e' vero, sulle reti locali il discorso e' diverso). E' per questo che solo il client che possiede il giusto IP sara' in grado di vedere la risposta spedita dal server, contenete il numero pseudo-casuale.

Con tecniche di IP spoofing si riesce facilmente a falsificare l'indirizzo IP di una macchina?
In altre parole: Se faccio il traceroute dell'indirizzo finto, dovrei comunque riuscire a risalire la catena dei router attraversati fino al finto, oppure risalgo la catena fino all'IP vero?
Si fa il traceroute VERO dell'indirizzo FINTO. In teoria, se i vari routers avessero un po' di ingegno, non si potrebbe fare neanche spoofing (o quasi).

In pratica puo' succedere questo:

A(F) ---> B ---> C ---> D
/
F ---> E --->--+

A ti manda un pacchetto fingendosi F. B, che controlla la sottorete A, ed in teoria non dovrebbe veder passare pacchetti DA F verso "NON A", invece passa questo strano pacchetto "F verso D". Lo stesso fa C, che "dovrebbe" vedere arrivare i pacchetti di F solo da E (ma C non puo' sapere se F sia anche collegato o no a B). D si vede arrivare un pacchetto da un certo "F" che arriva da "C", di cui si fida e che in passato gli ha mandato pacchetti veri di F.
Un traceroute D-->F rivela: D, C, E, F ... B e A sono rimasti fuori.
E' possibile naturalmente sapere se F stia originando una connessione con D. A non puo' impedirlo. Pero', sapere che quel pacchetto "F->D" e' spoofato non ti fa trovare A

- - - Aggiornato - - -

scusa per le scritte bianche basta copia e incollarlo su un file word cambiare il colore e il gioco è fatto BUONA LETTURA