Neue Antwort erstellen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

Unsere Datenschutzerklärung wurde aktualisiert. Mit der Nutzung unseres Forums akzeptierst Du unsere Datenschutzerklärung. Du bestätigst zudem, dass Du mindestens 16 Jahre alt bist.

Die letzte Antwort auf dieses Thema liegt mehr als 365 Tage zurück. Das Thema ist womöglich bereits veraltet. Bitte erstellen Sie ggf. ein neues Thema.

Informationen
Frage Bitte beantworten Sie die untenstehende Frage bzw. lösen Sie die untenstehende Aufgabe.
Nachricht
Internet-Adressen werden automatisch erkannt und umgewandelt.
Smiley-Code wird in Ihrer Nachricht automatisch als Smiley-Grafik dargestellt.
Sie können BBCodes zur Formatierung Ihrer Nachricht nutzen.

Vorherige Beiträge 59

  • Hatte im Quelltext von Zombienator noch einen kleine Fehler drin (vergessen Bereich zu clearen). Ist mir nicht aufgefallen, weil ich das Ding unter Vista geschrieben habe. Hab den Quelltext weiter oben angepasst.

    Zur Info:
    Der Zombienator erkennt natürlich nicht alle RootKits, nur einfache Prozesshider. Er listet auch nicht alle Zomies auf, nur die, die ihre Ursache durch ein offenes Handle im Usermode haben.
    Zombies erscheinen unter dem Prozess, der das Handle nicht geschlossen hat. RootKits erscheinen unter dem Prozess, der ein Handle auf das RootKit offen hat. Werden Prozesse während des Scans gestartet, kann es zu Fehlinterpretationen kommen. :-)
  • Auch hier würde mich mal interessieren, ob Zombinator unter Vista Zombieprozesse findet - und unter welchem Prozess diese Zombies auftauchen. Bitte mal eine zeitlang mit dem IE surfen, IE nicht schließen, und dann scannen. 8O
  • Jac de Lad;690213 schrieb:

    Also ich blick schon lange nicht mehr durch. Für mich war und bleibt ein Handle eine Adresse, mit der ich auf ein Objekt (Bild, Icon, Fenster, Fensterobjekt, Brush...) zugreifen kann.:D

    Ist eben nicht immer eine Adresse, sonder oft ein Eintrag in einer Liste, darauf kommt es an. Eine Liste hat einen Punkt, an dem sie startet und einen Endpunkt, an dem das letzte Element steht. Kennt man den Startpunkt, sind im Prinzip alle Elemente auslesbar, auch wenn man sonst nichts über die Handles und die Objekte, auf die sie verweisen, weiß :-).

    Wenn ich mal einkaufen gehe, gibt mir meine Frau in der Regel eine Einkaufsliste mit. Ich weiß beim besten Willen nicht, was meine Frau so alles braucht - doch das Ding kann man von oben bis unten komplett abarbeiten und hat dann nicht vergessen. Die müsste natürlich keine Liste nehmen, sondern könnte mir die ganze Sachen auch unter die Fusssohlen, auf die Handflächen und auf den Rücken schreiben - ich würde dann aber garantiert die Hälfte vergessen, da ich keine Lust habe mich im Laden jedesmal komplett auszuziehen... :(

    Wenn man weiß, das man eine Liste hat, ist also alles viel unkomplizierter. :-)
  • Also ich blick schon lange nicht mehr durch. Für mich war und bleibt ein Handle eine Adresse, mit der ich auf ein Objekt (Bild, Icon, Fenster, Fensterobjekt, Brush...) zugreifen kann.:D

    Interessant ist es natürlich trotzdem.:-)
  • Kernelobjekt Handles

    AHT

    :lupe:Hab jetzt mal vor, einen kleinen Blick auf die Kernelobjekte und auf deren Handles zu werfen. Zu den Kernelobjekten gehören (grob umrissen) die Objekte, die durch APIs in der Kernel32.dll erstellt werden - also Prozesse, Threads, Dateien, Ordner, ...
    Aber was gehört genau zu diesen "Kernelobjekten"?
    Da gibt es nette native API, die einem in der Regel diese Frage recht gut beantwortet und diese Objekte auflisten kann: ZwQueryObject
    Hier dazu ein Quelltext in Profan:

    Quellcode

    1. '#####################################################################################
    2. '######### Native XProfan Code von AHT #########
    3. '######### Für Windows2000/XP #########
    4. '#####################################################################################
    5. Def @ZwQueryObject(5) !"NTDLL","ZwQueryObject"
    6. DEF @WideCharToMultiByte(8) !"kernel32","WideCharToMultiByte"
    7. DEF @LookupPrivilegeValue(3) !"advapi32","LookupPrivilegeValueA" 'Ermittelt aus dem Namen eines Privilegs dessen Luid.
    8. DEF @AdjustTokenPrivileges(6) !"advapi32","AdjustTokenPrivileges" 'Stellt Privilegien ein.
    9. DEF @OpenProcessToken(3) !"advapi32","OpenProcessToken" 'Öffnet Einstellprozess.
    10. DEF @GetCurrentProcess(0) !"kernel32","GetCurrentProcess" 'Ermittel das Handle des aktiven Prozesses.
    11. DEF @CopyMemory(3) !"kernel32","RtlMoveMemory"
    12. DEF @CloseHandle(1) !"kernel32","CloseHandle" 'Schließt ein Handle.
    13. Declare NT_Fehler&,Obj_INFO#,return&,Count&,Counter&,Obj_INFO2#,return2&
    14. Declare Stringbuffer#,TypeCount%
    15. Declare LUID#,TOKEN_PRIVILEGES#,Fehler&
    16. Set_Privilege_Status "SeDebugPrivilege",$2
    17. Set_Privilege_Status "SeSystemEnvironmentPrivilege",$2
    18. DIM Obj_INFO#,500
    19. LET NT_Fehler&=@ZwQueryObject(0,3,Obj_INFO#,@SizeOf(Obj_INFO#),@ADDR(return&))
    20. Dispose Obj_INFO#
    21. DIM Obj_INFO#,Return&
    22. LET NT_Fehler&=@ZwQueryObject(0,3,Obj_INFO#,@SizeOf(Obj_INFO#),@ADDR(return&))
    23. LET COUNT&=@long(Obj_INFO#,0)
    24. Let Counter&=4
    25. Let TypeCount%=1
    26. ADDSTRING "Anzahl der Objekt-Typen: "+@str$(@long(Obj_INFO#,0))
    27. Whilenot Counter&>@SizeOf(Obj_INFO#)-108
    28. ADDSTRING ""
    29. Addstring "Objekt-Typennummer: "+@str$(TypeCount%)
    30. Dim StringBuffer#,262
    31. @WideCharToMultiByte(0,0,@Long(Obj_INFO#,Counter&+4),-1,StringBuffer#,261,0,0)
    32. Addstring "Objekt-Typenname: "+@string$(StringBuffer#,0)
    33. Addstring "Anzahl der Objekte im System: "+@Str$(@long(Obj_INFO#,Counter&+8))
    34. Addstring "Anzahl der offenen Handles auf den Typ: "+@Str$(@long(Obj_INFO#,Counter&+12))
    35. Addstring "Maximale Anzahl der Objekte: "+@Str$(@long(Obj_INFO#,Counter&+32))
    36. Addstring "Maximale Anzahl der Handles auf den Objekttyp: "+@Str$(@long(Obj_INFO#,Counter&+36))
    37. Addstring "Flags für ungültige Attribute: $"+@Hex$(@long(Obj_INFO#,Counter&+56))
    38. Addstring "GENERIC_READ: $"+@Hex$(@long(Obj_INFO#,Counter&+60))
    39. Addstring "GENERIC_WRITE: $"+@Hex$(@long(Obj_INFO#,Counter&+64))
    40. Addstring "GENERIC_EXECUTE: $"+@Hex$(@long(Obj_INFO#,Counter&+68))
    41. Addstring "GENERIC_ALL: $"+@Hex$(@long(Obj_INFO#,Counter&+72))
    42. Addstring "Gültige Zugriffsrechte: $"+@Hex$(@long(Obj_INFO#,Counter&+76))
    43. Dispose StringBuffer#
    44. 'Let Counter&=Counter&+108
    45. Let Counter&=Counter&+@Word(Obj_INFO#,Counter&+2)
    46. Let Counter&=Counter&+96
    47. While Counter&/4<>@int(Counter&/4)
    48. Let Counter&=Counter&+1
    49. wend
    50. Inc TypeCount%
    51. wend
    52. Dispose Obj_INFO#
    53. @editbox("Rückgaben",1)
    54. Proc Set_Privilege_Status
    55. Parameters Privilege_name$,Aktive&
    56. Declare NewState&,AH_Token_Handle&,LU_SYSTEM$
    57. DIM TOKEN_PRIVILEGES#,16
    58. DIM LUID#,8
    59. Clear LUID#,LU_SYSTEM$
    60. @LookupPrivilegeValue(@ADDR(LU_SYSTEM$),@ADDR(Privilege_name$),LUID#)
    61. CLEAR AH_Token_Handle&
    62. LET FEHLER&=@OpenProcessToken(@GetCurrentProcess(),$20,@ADDR(AH_Token_Handle&))
    63. LONG TOKEN_PRIVILEGES#,0=1
    64. LET NewState&=TOKEN_PRIVILEGES#
    65. @CopyMemory(NewState&+4,LUID#,8)
    66. LET NewState&=Aktive&
    67. Clear Aktive&
    68. IF @or(NewState&,$2)=NewState&
    69. LET Aktive&=@or(AKTIVE&,$2)
    70. Endif
    71. IF @or(NewState&,$80000000)=NewState&
    72. LET Aktive&=@or(AKTIVE&,$80000000)
    73. Endif
    74. LONG TOKEN_PRIVILEGES#,12=Aktive&
    75. LET FEHLER&=@AdjustTokenPrivileges(AH_Token_Handle&,0,TOKEN_PRIVILEGES#,0,0,0)
    76. If AH_TOKEN_Handle&<>0
    77. @CLOSEHANDLE(AH_Token_Handle&)
    78. endif
    79. Dispose TOKEN_PRIVILEGES#
    80. Dispose LUID#
    81. endproc
    Alles anzeigen


    Wenn man weiß, was ein Handle genau ist, kann man damit alleine schon ganz interessante Sachen machen - einen kurzen Abriss davon habe ich ja hier bereits gegeben. Jetzt soll die Sache noch etwas handfester werden...:-)

    Schauen wir uns also erst einmal die Werte für Kernelhandles an.
    Dazu hier folgender Quelltext:

    Quellcode

    1. DEF OpenProcess(3) !"KERNEL32","OpenProcess" 'Prozesshandle öffnen
    2. DEF OpenThread(3) !"KERNEL32","OpenThread" 'Threadhandle öffnen
    3. DEF GetCurrentProcessId(0) !"kernel32","GetCurrentProcessId" 'Ermittel das Handle des aktiven Prozesses.
    4. DEF GetCurrentThreadId(0) !"kernel32","GetCurrentThreadId" 'Ermittel das Handle des aktiven Threads.
    5. Def CloseHandle(1) !"KERNEL32","CloseHandle" 'Handle schließen
    6. Declare Handle1&, Handle&[20], Handle3&, Zaehler%
    7. Windowstyle 31+512
    8. WindowTitle "Handletest für Kernelhandles"
    9. Window 0,0-640,440
    10. Usermessages $10
    11. Zaehler%=0
    12. While Zaehler%<11
    13. Handle&[Zaehler%]=OpenThread($1,0,GetCurrentThreadId())
    14. Print Str$(int(Zaehler%+1))+". Handle (Threadhandle) = "+Str$(Handle&[Zaehler%])
    15. Zaehler%=Zaehler%+1
    16. wend
    17. While Zaehler%<21
    18. Handle&[Zaehler%]=OpenProcess($1,0,GetCurrentProcessId())
    19. Print Str$(int(Zaehler%+1))+". Handle (Prozesshandle) = "+Str$(Handle&[Zaehler%])
    20. Zaehler%=Zaehler%+1
    21. wend
    22. While %Umessage<>$10
    23. Waitinput
    24. wend
    25. Zaehler%=0
    26. While Zaehler%<21
    27. CloseHandle(Handle&[Zaehler%])
    28. Zaehler%=Zaehler%+1
    29. wend
    Alles anzeigen

    Und hier das Ergebnis als Bild:
    [Blockierte Grafik: http://www.postimage.org/aVB2QmS.jpg]

    Auch hier sieht das ganze aus wie eine Liste. Der Abstand Abstand zwischen den einzelnen Handles ist ein vielfaches von 4 (das reicht genau zum Abspeichern einer Adresse):lupe:. Diese Liste scheint wohl bei 4 zu beginnen. Startet man das Programm ein zweites Mal, erscheinen die selben Zahlen für die Handles - sie verweisen aber auf andere Objekte. Diese Liste, um die es hier geht, kann also nicht global und für jeden Prozess gültig sein, sondern ist eine "lokale" Liste, die nur im jeweiligen Prozess existiert.
    Ein Kernelobjekthandle ist also der Einsprungspunkt in eine Liste, die nur für den jeweiligen Prozess Gültigkeit hat :vertrag:.

    Was bringt einem das aber? Auf Sachen, die nur lokal existieren, kann man normalerweise ja nicht von anderen Prozessen aus zugreifen :(...
    Im Prinzip bringt einem das schon eine ganze Menge, denn es gibt da eine wundervolle API, und die heißt DuplicateHandle.
    Über diese API lassen sich Handles aus einem anderen Prozess in den eigenen hineinkopieren - interessante Sache...:hurra:

    Ohne zu wissen, welches Objekt hinter einem bestimmte Handle steht, könnte man einen Prozess mit DuplicateHandle - ab dem Handle 4 bis zu einem Wert, an dem gewiss kein Handle mehr ist - beschießen und sich (soweit der Prozess das wegen seiner Zugriffsrechte zulässt) alle Handles des fremden Prozesses in seinen eigenen Prozessbereich "herüberholen".
    Hat man das Handle erst mal in seinem Bereich, kann man quasi alles damit machen. Eine Möglichkeit wäre zum Beispiel zu ermitteln, welche Dateien oder Registryschlüssel ein fremdes Programm geöffnet hat :lol:.
    Desweiteren kann man damit auch nach RootKits oder Zombieprozessen scannen, wie dieser Quelltext eines kompletten Programmes beweist:

    Quellcode

    1. '#####################################################################################
    2. '######### Zombinator XProfan Code von AHT #########
    3. '######### Für Windows2000/XP/Vista #########
    4. '#####################################################################################
    5. '#####################################################################
    6. '######### APIs deklarieren #########
    7. '#####################################################################
    8. DEF CheckTokenMembership(3) !"advapi32", "CheckTokenMembership" 'Prüft, ob eine Gruppe einem Token angehört und aktiv ist
    9. DEF ShellExecute(6) !"Shell32", "ShellExecuteA" 'Entspricht ShelExec in Profan, hier können aber Parameter angegeben werden
    10. Def GetModuleFileNameEx(4) !"Psapi","GetModuleFileNameExA" 'Ermittelt den Pfad eines geladenen Moduls
    11. Def CreateToolhelp32Snapshot(2) !"Kernel32", "CreateToolhelp32Snapshot" 'Erzeugt Systemschnappschuss
    12. Def Process32First(2) !"Kernel32", "Process32First" 'Ersten Prozess im Schnappschuss holen
    13. Def Process32Next(2) !"Kernel32", "Process32Next" 'Weitere Prozesse im Schnappschuss holen
    14. Def CloseHandle(1) !"Kernel32", "CloseHandle" 'Kernelhandle schließen
    15. DEF LookupPrivilegeValue(3) !"advapi32","LookupPrivilegeValueA" 'LUID (8-Byte Registrierungszahl) von Privileg erhalten
    16. DEF AdjustTokenPrivileges(6) !"advapi32","AdjustTokenPrivileges" 'Privilegien einstellen
    17. DEF OpenProcessToken(3) !"advapi32","OpenProcessToken" 'Tokenhandle öffnen
    18. DEF CopyMemory(3) !"kernel32","RtlMoveMemory" 'kopiert einen Speicherbereich
    19. DEF GetCurrentProcess(0) !"KERNEL32","GetCurrentProcess" 'Handle auf den aktuellen Prozess holen
    20. DEF ImageList_Create(5) !"COMCTL32","ImageList_Create" 'Imageliste erstellen
    21. DEF ImageList_AddIcon(2) !"COMCTL32","ImageList_AddIcon" 'Icon zur Imageliste hinzufügen
    22. DEF ImageList_Destroy(1) !"COMCTL32","ImageList_Destroy" 'Imageliste löschen
    23. DEF LoadIcon(2) ! "USER32","LoadIconA" 'Icon laden
    24. DEF CreateStatus(4) !"comctl32","CreateStatusWindow" 'Statusbar erzeugen
    25. Def SetWindowPos(7) !"User32","SetWindowPos" 'Fensterposition setzen
    26. Def SetTimer(4) !"USER32","SetTimer" 'Timer setzen
    27. Def KillTimer(2) !"USER32","KillTimer" 'Timer löschen
    28. Def OpenProcess(3) !"Kernel32", "OpenProcess" 'Prozesshandle öffnen
    29. DEF GetDlgCtrlID(1) !"USER32","GetDlgCtrlID" 'ID eines Controls ermitteln
    30. DEF ButtonClicked(1) GetDlgCtrlID(&(1)) = -%MENUITEM 'Wurde Button gedrückt?
    31. DEF DuplicateHandle(7) !"KERNEL32","DuplicateHandle" 'Handle in den eigenen Prozess kopieren
    32. Def NtQueryInformationProcess(5) !"NTDLL","NtQueryInformationProcess" 'Prozess ID ermitteln
    33. Def GetProcessTimes(5) !"KERNEL32","GetProcessTimes" 'Ermittelt unter anderem, wann ein Prozess beendet wurde
    34. Def GetLastError(0) !"KERNEL32","GetLastError" 'Fehlercode auslesen
    35. Def SetLastError(1) !"KERNEL32","SetLastError" 'Fehlercode setzen
    36. '#####################################################################
    37. '######### Variablen deklarieren #########
    38. '#####################################################################
    39. Declare SID#, Member&, Counter&, Prog_to_Start$, StartParams$, Fehler&, Operation$, ProgDir$
    40. Declare TOKEN_PRIVILEGES#, LUID#, Iconname#, Hicon&, Imagelist&, Positions#, STATUSBAR&
    41. Declare PROGRESSHandle&, Statustext$, Process_Listview&, neu_scannen&, ButtonFONT&
    42. Declare Spaltentext$, LVC#, Zeile#, Durch%, Hauptfensterbreite&, Hauptfensterhöhe&
    43. Declare TIMER_ID&, LISTVIEW_TEXT#, PROCESSENTRY#, Prozess_Counter&, Itemnumber&
    44. Declare Filename#, ALL_Processes$, NTFehler&, P_Basic#, RetLength&
    45. Declare CreationTime#, ExitTime#, KernelTime#, UserTime#, P_NOW!, P_INC!
    46. '#####################################################################
    47. '######### Strukturen festlegen #########
    48. '#####################################################################
    49. Struct LVCOLUMN = Mask&, FMT&, CX&, Text&, Textlänge&, Subitem&
    50. Struct LVITEM = IMASK&, ITEM&, ISUBITEM&, State&, StateMask&, ITEXT&, ITEXTMAX&, IIMAGE&, ILPARAM&
    51. Struct PROCESSENTRY32=dwSize&,cntUsage&,th32ProcessID&,th32DefaultHeapID&,th32ModuleID&,cntThreads&,th32ParentProcessID&,pcPriClassBase&,dwPrFlags&,szExeFile$(262)
    52. '#####################################################################
    53. '######### Hauptprogrammteil #########
    54. '#####################################################################
    55. 'Älter Windowsversionen ausschalten
    56. IF @Val($WINVER)<5
    57. @messagebox("Auf dieser Windowsversion läuft Zombienator leider nicht, das Programm wird beendet!","Sorry, falsche Windowsversion!",16)
    58. End
    59. endif
    60. 'Bereiche deklarieren
    61. Dim Zeile#, LVITEM
    62. Dim LVC#, LVCOLUMN
    63. Dim PROCESSENTRY#,PROCESSENTRY32
    64. Dim Filename#, 1000
    65. DIM P_Basic#,24
    66. DIM CreationTime#, 8
    67. DIM ExitTime#, 8
    68. DIM KernelTime#, 8
    69. DIM UserTime#, 8
    70. 'Überprüft, ob der User ein Administrator ist
    71. DIM SID#, 16
    72. LONG SID#, 0 = 513
    73. LONG SID#, 4 = 83886080
    74. LONG SID#,8 = 32
    75. LONG SID#, 12 = 544
    76. CheckTokenMembership(0, SID#, ADDR(Member&))
    77. Dispose SID#
    78. 'Als Admin starten, wenn keine Adminrechte vorliegen
    79. Case Member& = 0 : StartAsAdmin
    80. 'Privilegien aktivieren
    81. Set_Privilege_Status "SeDebugPrivilege",$2
    82. 'Hauptfenster wird erstellt
    83. Windowstyle 31 + 512
    84. WindowTitle "Zombienator von AHT"
    85. Window 0, 0 - 640, 440
    86. Cls RGB(255,255,100)
    87. Usermessages $10 'Usermessage zum beenden des Programmes
    88. 'Imageliste für Listview erstellen
    89. Dim Iconname#,25
    90. Imagelist&=ImageList_Create(16,16,$1 | $8,3,3) 'Imagelist erzeugen
    91. String Iconname#,0="Windows"
    92. Hicon&=loadicon(%HINSTANCE,Iconname#)
    93. ImageList_AddIcon(Imagelist&,HIcon&) 'Index 0 ist "normaler Prozess"
    94. String Iconname#,0="GESICHT"
    95. Hicon&=loadicon(%HINSTANCE,Iconname#)
    96. ImageList_AddIcon(Imagelist&,HIcon&) 'Index 1 ist "RootKit"
    97. String Iconname#,0="MUELL"
    98. Hicon&=loadicon(%HINSTANCE,Iconname#)
    99. ImageList_AddIcon(Imagelist&,HIcon&) 'Index 2 ist "Zombie"
    100. Dispose Iconname#
    101. 'Controls erstellen
    102. ButtonFONT& = Create("Font", "Times New Roman", 15, 5, 0, 0, 0) 'Font erstellen
    103. Dim Positions#, 8
    104. Long Positions#, 0=250
    105. Long Positions#, 4=-1
    106. STATUSBAR& = CreateStatus($50000900 | $4000000, ADDR(Statustext$), %HWND, 2701) 'Statusbar erstellen
    107. Sendmessage(STATUSBAR&,$404,2,Positions#)
    108. Dispose Positions#
    109. LET PROGRESSHandle& = Control("msctls_progress32", "", $10000 + $40000000 + $10000000 + $1000, 3, 4, 250 - 8, Height(Statusbar&) - 7, Statusbar&, 5555, %Hinstance) 'Progressbar erzeugen
    110. LET Process_Listview& = control("SysListView32", "", $40 + $54018001 + $4 + $8 + $800000, 40, 20, ABS( WIDTH(%HWND) - 89), ABS(HEIGHT(%HWND) - 130), %Hwnd, 2698, %Hinstance) 'Prozesslistview erstellen
    111. sendmessage(Process_Listview&, $1036, 0, $20 | $1 | $400)
    112. LET Spaltentext$ = "PID"
    113. LVC#.TEXT& = ADDR(Spaltentext$)
    114. LVC#.MASK& = $0001 + $0002 + $0004 + $0008
    115. LVC#.FMT& = 0
    116. LVC#.CX& = 90
    117. LVC#.Subitem& = 0
    118. LVC#.Textlänge& = LEN(Spaltentext$)
    119. sendmessage(Process_Listview&, $1000+27, 0, LVC#) 'Kopfzeile dem Listview hinzufügen
    120. LET Spaltentext$ = "Status"
    121. LVC#.TEXT& = ADDR(Spaltentext$)
    122. LVC#.Textlänge& = LEN(Spaltentext$)
    123. LVC#.CX& = 70
    124. sendmessage(Process_Listview&, $1000 + 27, 1, LVC#) 'Kopfzeile dem Listview hinzufügen
    125. LET Spaltentext$ = "Dateiname"
    126. LVC#.TEXT& = ADDR(Spaltentext$)
    127. LVC#.Textlänge& = LEN(Spaltentext$)
    128. LVC#.CX& = WIDTH(Process_Listview&) - (70 + 90)
    129. sendmessage(Process_Listview&,$1000+27,2,LVC#) 'Kopfzeile dem Listview hinzufügen
    130. sendmessage(Process_Listview&,$1003,1,Imagelist&) 'Die Imageliste dem Listview zuweisen
    131. neu_scannen&=@Control("Button","",$8000000 + $10000 + $40000000 + $10000000 + $1000 + $2000, 40, ABS(HEIGHT(%HWND)-100), ABS( WIDTH(%HWND) - 89), 30, %HWND, 2119, %HINSTANCE)
    132. SetFont neu_scannen&,ButtonFONT&
    133. Settext neu_scannen&,"neu &scannen"
    134. TIMER_ID&=SetTimer(%HWND,1278,233,ProcAddr("Positioner",4)) 'Timer zum aktualisieren des Fensters
    135. Scan_for_Prozesses
    136. While %Umessage<>$10
    137. Waitinput
    138. IF ButtonClicked(neu_scannen&)
    139. Setmenuitem 0
    140. Scan_for_Prozesses
    141. endif
    142. wend
    143. EndProgramm 'Programm beenden
    144. '#####################################################################
    145. '######### Prozeduren #########
    146. '#####################################################################
    147. 'Prozedur zum Scannen nach Prozessen, Zombieprozessen und RootKit-Prozessen
    148. Proc Scan_for_Prozesses
    149. Declare hSnapshot&, Result_HL&, Prozessname$, PHandle&, NetxItem&, Process_PID&
    150. Declare Handle_not_OK%, HandleWert&, Dup_Handle&, Zombies&, RootKits&, P_NOW!, P_INC!
    151. EnableWindow neu_scannen&,0
    152. EnableWindow Process_Listview&,0
    153. sendmessage(PROGRESSHandle&, $0400 + 2, 0, 0)
    154. Usecursor 2
    155. Let Statustext$ = "Prozesse werden gescannt..."
    156. sendmessage(Statusbar&, $401, 1, addr(Statustext$))
    157. sendmessage(Statusbar&, $410, 1, addr(Statustext$))
    158. ALL_Processes$ = ","
    159. sendmessage(Process_Listview&,$1009,0,0)
    160. Clear PROCESSENTRY#, Prozess_Counter&, NetxItem&, Zombies&, RootKits&
    161. Let PROCESSENTRY#.dwSize&=298
    162. LET hSnapshot& = CreateToolhelp32Snapshot($2, 0) 'Schnappschuss aller sichtbaren Prozesse erstellen
    163. IfNot hSnapshot& = -1
    164. LET Result_HL& = Process32First(hSnapshot&, PROCESSENTRY#) 'Ersten Prozess holen
    165. While and(Result_HL& = 1, %UMESSAGE <> $10)
    166. Addzeile_To_Listview Process_Listview&, Prozess_Counter&, 0, STR$(PROCESSENTRY#.th32ProcessID&), 0 'PID ins Listview einfügen
    167. ALL_Processes$ = ALL_Processes$ + STR$(PROCESSENTRY#.th32ProcessID&) + "," 'PID merken, damit man später weiß, welche Prozesse sichtbar waren
    168. Addzeile_To_Listview Process_Listview&, Prozess_Counter&, 1, "normal", 0 'Ins Listview eintragen, dass es sich um einen normalen Prozess handelt
    169. PHandle& = OpenProcess($400 | $10, 0, PROCESSENTRY#.th32ProcessID&) 'Prozess öffnen, um Pfad zu holen
    170. IF PHandle& > 0
    171. Clear Filename#
    172. GetModuleFilenameEx(PHandle&, 0, Filename#, 513) 'Wenn sich Prozessdaten auslesen lassen, kompletten Pfad holen
    173. If len(Trim$(String$(Filename#, 0))) > 3
    174. Prozessname$ = String$(Filename#, 0)
    175. Else
    176. Prozessname$ = PROCESSENTRY#.szExeFile$
    177. endif
    178. Closehandle(PHandle&)
    179. Else
    180. Prozessname$ = PROCESSENTRY#.szExeFile$ 'Wenn sich Prozessdaten nicht auslesen lassen, Dateinamen verwenden
    181. endif
    182. Addzeile_To_Listview Process_Listview&, Prozess_Counter&, 2, Prozessname$, 0 'Pfad oder Dateinamen in Listview eintragen
    183. LET Result_HL& = Process32Next(hSnapshot&, PROCESSENTRY#)
    184. LET Prozess_Counter& = Prozess_Counter& + 1 'Zählen, wie viele Prozesse es sind
    185. EndWhile
    186. Closehandle(hSnapshot&)
    187. endif
    188. P_INC! = 100 / Prozess_Counter&
    189. EnableWindow Process_Listview&,1
    190. Let Statustext$ = "Kernelandles werden gescannt..."
    191. sendmessage(Statusbar&, $401, 1, addr(Statustext$))
    192. sendmessage(Statusbar&, $410, 1, addr(Statustext$))
    193. While and(Get_List_Text(Process_Listview&, NetxItem&, 0) <> "", %UMESSAGE <> $10)
    194. Clear Handle_not_OK%, HandleWert&
    195. Process_PID& = Val(Get_List_Text(Process_Listview&, NetxItem&, 0)) 'Hole PID eines gefundenen Prozesses aus dem Listview
    196. SetLastError(0)
    197. PHandle& = OpenProcess($2000000, 0, Process_PID&) 'Prozess öffnen, um Handles zu kopieren
    198. Let Fehler&=GetLastError()
    199. Let Statustext$ = "Kernelhandles werden gescannt (PID " + str$(Process_PID&) + ")..."
    200. sendmessage(Statusbar&, $401, 1, addr(Statustext$))
    201. sendmessage(Statusbar&, $410, 1, addr(Statustext$))
    202. If PHandle& <> 0 'Wenn sich Handles kopieren lassen...
    203. HandleWert& = 4 'Erster gültiger Handlewert
    204. While and(Handle_not_OK% < 2500, %UMESSAGE <> $10) 'Solange nach Handles suchen, bis sich 2500 mal hintereinander kein Handle kopieren lässt
    205. Let Fehler& = DuplicateHandle(PHandle&, HandleWert&, GetCurrentProcess(), addr(Dup_Handle&), $400 | $10, 0, 0) 'Versuche, Handle zu kopieren
    206. If Fehler& = 0
    207. Handle_not_OK% = Handle_not_OK% + 1 'Zählen, wie oft sich kein Handle kopieren lässt
    208. Else 'Wenn sich ein Handle kopieren lässt...
    209. NTFEHLER& = NtQueryInformationProcess(Dup_Handle&, 0, P_Basic#, 24, addr(RetLength&)) 'PID aus dem Handle ermitteln
    210. IF NtFehler& = 0 'Wenn sich die PID ermitteln ließ (es sich also um einen Prozess handelt)...
    211. If instr("," + str$(int(long(P_Basic#,16))) + ",",All_Processes$) = 0 '...und wenn es kein sichtbarer Prozess ist...
    212. GetProcessTimes(Dup_Handle&, CreationTime#, ExitTime#, KernelTime#, UserTime#) 'Zeit holen, wann der Prozess beendet wurde
    213. If and(Long(ExitTime#,0) = 0, Long(ExitTime#,4) = 0) 'Wenn er noch läuft, muss der Prozess ein RootKit sein...
    214. NetxItem& = NetxItem& + 1
    215. Addzeile_To_Listview Process_Listview&, NetxItem&, 0, str$(int(long(P_Basic#,16))), 1
    216. Addzeile_To_Listview Process_Listview&, NetxItem&, 1, "RootKit", 0
    217. Clear Filename#
    218. GetModuleFilenameEx(Dup_Handle&, 0, Filename#, 513)
    219. Prozessname$ = String$(Filename#, 0)
    220. Case len(Prozessname$) > 3 : Addzeile_To_Listview Process_Listview&, NetxItem&, 2, Prozessname$, 0
    221. RootKits& = RootKits& +1
    222. Handle_not_OK% = 0
    223. else '...ansonsten ist es wohl ein Zombieprozess
    224. NetxItem& = NetxItem& + 1
    225. Addzeile_To_Listview Process_Listview&, NetxItem&, 0, str$(int(long(P_Basic#,16))), 2
    226. Addzeile_To_Listview Process_Listview&, NetxItem&, 1, "Zombie", 0
    227. Clear Filename#
    228. GetModuleFilenameEx(Dup_Handle&, 0, Filename#, 513)
    229. Prozessname$ = String$(Filename#, 0)
    230. Case len(Prozessname$) > 3 : Addzeile_To_Listview Process_Listview&, NetxItem&, 2, Prozessname$, 0 'Nur zur Sicherheit, Zombies haben keinen Pfad mehr, den man auslesen kann
    231. Zombies& = Zombies& +1
    232. Handle_not_OK% = 0
    233. endif
    234. endif
    235. endif
    236. CloseHandle(Dup_Handle&)
    237. endif
    238. LET HandleWert& = HandleWert& + 4 'Kleinster zwischen zwei Kernelhandles ist 4, deshalb 4 dazuzählen
    239. wend
    240. CloseHandle(PHandle&)
    241. endif
    242. NetxItem& = NetxItem& + 1 'Zeigt auf den nächsten sichtbaren Prozess im Listview
    243. P_NOW! = P_NOW! + P_INC!
    244. sendmessage(PROGRESSHandle&, $0400 + 2, int(P_NOW!), 0)
    245. wend
    246. Let Statustext$ = "RootKits: " + Str$(RootKits&) + " / Zombies: " + Str$(Zombies&) 'Das wars, Ergebnis ausgeben!
    247. sendmessage(Statusbar&, $401, 1, addr(Statustext$))
    248. sendmessage(Statusbar&, $410, 1, addr(Statustext$))
    249. EnableWindow neu_scannen&,1
    250. EnableWindow Process_Listview&,1
    251. Usecursor 0
    252. Beep
    253. endproc
    254. 'Ein Programm mit Adminrechten starten
    255. Proc StartAsAdmin
    256. Clear Counter&, Prog_to_Start$, StartParams$
    257. Counter& = 1
    258. Whilenot Counter& > %ParCount
    259. Let StartParams$ = StartParams$ + CHR$(34) + Par$(Counter&) + CHR$(34) + " "
    260. LET counter& = Counter& + 1
    261. wend
    262. LET StartParams$ = trim$(StartParams$)
    263. LET Operation$ = "RUNAS"
    264. LET Progdir$ = Left$($ProgDir, Len($Progdir) - 1)
    265. Let Prog_to_Start$ = Par$(0)
    266. LET Fehler& = ShellExecute(%HWND, addr(Operation$), addr(Prog_to_Start$), addr(StartParams$), addr(ProgDir$), 1)
    267. IF Fehler&>31
    268. End
    269. endif
    270. endproc
    271. 'Prozedur zum Beenden des Programmes
    272. Proc EndProgramm
    273. CASE TIMER_ID&<>0 : KiLLTIMER(%HWND,1278)
    274. CASE neu_scannen&<>0 : Destroywindow(neu_scannen&)
    275. DELETEOBJECT ButtonFONT&
    276. Dispose LVC#
    277. Dispose Zeile#
    278. Dispose PROCESSENTRY#
    279. Dispose Filename#
    280. Dispose P_Basic#
    281. Dispose CreationTime#
    282. Dispose ExitTime#
    283. Dispose KernelTime#
    284. Dispose UserTime#
    285. Case Imagelist& <> 0 : ImageList_Destroy(Imagelist&)
    286. end
    287. endproc
    288. 'Prozedur zum aktualisieren der Fenster
    289. Proc Positioner
    290. IF Durch%=0
    291. Durch%=1
    292. IF or(Hauptfensterbreite& <> WIDTH(%HWND), Hauptfensterhöhe& <> HEIGHT(%HWND))
    293. SetWindowPos Statusbar& = 0, 0 - 0, 0; 0
    294. Hauptfensterbreite& = WIDTH(%HWND)
    295. Hauptfensterhöhe& = HEIGHT(%HWND)
    296. SetWindowPos(Process_Listview&,0, 40, 20, ABS( WIDTH(%HWND) - 89), ABS(HEIGHT(%HWND) - 130), $4)
    297. SetWindowPos(neu_scannen&, 0, 40, ABS(HEIGHT(%HWND) - 100), ABS( WIDTH(%HWND) - 89), 30, $4)
    298. Sendmessage(Process_Listview&,$101E,2,WIDTH(Process_Listview&) - (70 + 90))
    299. endif
    300. Durch%=0
    301. endif
    302. endproc
    303. 'Prozedur zum Aktivieren von Privilegien
    304. Proc Set_Privilege_Status
    305. Parameters Privilege_name$, Aktive&
    306. Declare NewState&, AH_Token_Handle&, LU_SYSTEM$
    307. DIM TOKEN_PRIVILEGES#, 16
    308. DIM LUID#, 8
    309. Clear LUID#, LU_SYSTEM$
    310. LookupPrivilegeValue(ADDR(LU_SYSTEM$), ADDR(Privilege_name$), LUID#)
    311. CLEAR AH_Token_Handle&
    312. LET FEHLER& = OpenProcessToken(GetCurrentProcess(), $20, ADDR(AH_Token_Handle&))
    313. LONG TOKEN_PRIVILEGES#, 0 = 1
    314. LET NewState& = TOKEN_PRIVILEGES#
    315. CopyMemory(NewState& + 4, LUID#, 8)
    316. LET NewState& = Aktive&
    317. Clear Aktive&
    318. IF or(NewState&, $2) = NewState&
    319. LET Aktive& = or(AKTIVE&, $2)
    320. Endif
    321. IF @or(NewState&, $80000000) = NewState&
    322. LET Aktive& = or(AKTIVE&, $80000000)
    323. Endif
    324. LONG TOKEN_PRIVILEGES#, 12 = Aktive&
    325. LET FEHLER& = AdjustTokenPrivileges(AH_Token_Handle&, 0, TOKEN_PRIVILEGES#, 0, 0, 0)
    326. If AH_TOKEN_Handle& <> 0
    327. CLOSEHANDLE(AH_Token_Handle&)
    328. endif
    329. Dispose TOKEN_PRIVILEGES#
    330. Dispose LUID#
    331. endproc
    332. 'Prozedur zum hinzufügen einer Listviewzeile
    333. Proc Addzeile_To_Listview
    334. Parameters Lvhndl&, Index&, spalte&, Text$, Image&
    335. Clear Zeile#
    336. IF Image&=0
    337. Zeile#.IMASK&=$0001
    338. else
    339. Zeile#.IMASK&=$000B
    340. Zeile#.IIMAGE&=IMAGE&
    341. endif
    342. Zeile#.ITEM&=Index&
    343. Zeile#.ITEXT&=Addr(Text$)
    344. Zeile#.ITEXTMAX&=Len(Text$)
    345. IF spalte&=0
    346. ItemNumber& = Sendmessage(Lvhndl&, $1007, 0, Zeile#)
    347. else
    348. Zeile#.ISUBITEM&=spalte&
    349. ItemNumber& = Sendmessage(Lvhndl&, $102E, Index&, Zeile#)
    350. endif
    351. Return ItemNumber&
    352. Endproc
    353. 'Listviewzeile auslesen
    354. Proc Get_List_Text
    355. Parameters LV_HANDLE&,Priv_List_Index&,spalte&
    356. Declare ERG$
    357. DIM LISTVIEW_TEXT#, 1100
    358. CLEAR Zeile#
    359. Zeile#.IMASK& = $1
    360. Zeile#.ITEM& = Priv_List_Index&
    361. Zeile#.ITEXT& = LISTVIEW_TEXT#
    362. Zeile#.ITEXTMAX& = 1000
    363. Zeile#.ISUBITEM& = spalte&
    364. IF @sendmessage(LV_HANDLE&, $1005, Priv_List_Index&, Zeile#) = 1
    365. Let ERG$ = String$(LISTVIEW_TEXT#, 0)
    366. endif
    367. Dispose LISTVIEW_TEXT#
    368. Return ERG$
    369. Endproc
    Alles anzeigen

    [Blockierte Grafik: http://www.postimage.org/aVBhGKr.jpg]
    Download: Von meiner Homepage oder Link auf Anfrage per PM.

    RootKits: Unsichtbare Prozesse, in der Regel Trojaner.
    Zombieprozesse: Bereits beendete Prozesse, die nicht im Taskmanager erscheinen und Speicherplatz im Kernel belegen, da noch ein Handle auf sie offen ist.

    PS: Ich bitte darum, den obigen "Zombienator" Quelltext nirgendwo anders zu veröffentlichen oder in eigenen Programmen zu verwenden, ohne mich vorher zu fragen. :-)

    So, das wars erst mal hier von mir - vielleicht erweitert das ja mal irgendeiner...
  • Frabbing;686711 schrieb:

    Hehe, klasse Code. Da werden Icons aufgelistet, die ich noch nie vorher bei mir gesehen hab. :-D
    Funktioniert sehr gut...

    Was genau suchst du denn für Hooks? Eine Methode um zu ermitteln, ob ein Handle zu einem Hook führt? Sowas wie IsHook()?

    Ja genau, so etwas wie "IsHook".
  • Hehe, klasse Code. Da werden Icons aufgelistet, die ich noch nie vorher bei mir gesehen hab. :-D
    Funktioniert sehr gut...

    Was genau suchst du denn für Hooks? Eine Methode um zu ermitteln, ob ein Handle zu einem Hook führt? Sowas wie IsHook()?
  • Hier mal etwas Code

    Quellcode

    1. Def GetDC(1) ! "USER32","GetDC"
    2. Def DrawIconEx(9) ! "User32","DrawIconEx"
    3. DEF ExtractIcon(3) !"SHELL32","ExtractIconA"
    4. Def CreateSolidBrush(1) ! "GDI32","CreateSolidBrush"
    5. DEF GetSysColor(1) !"USER32","GetSysColor"
    6. Def DestroyIcon(1) !"USER32","DestroyIcon"
    7. Def GetIconInfo(2) !"USER32","GetIconInfo"
    8. DEF CreateStatus(4) !"comctl32","CreateStatusWindow"
    9. Windowstyle 31+512
    10. Windowtitle "Icon zeichnen, ohne welche zu laden"
    11. Window 0, 0 - %MAXX, %MAXY - 40
    12. SetTrueColor 1
    13. Declare Button&,IconHandle&,IconHolder$,DCButton&
    14. Declare Brush&, ICONINFO#, X&, y&, Statustext$, STATUSBAR&, Positions#
    15. Declare Erster%, Hauptfensterbreite&, Hauptfensterhöhe&, Erster2%, Count&
    16. DIM IconInfo#,20
    17. LET STATUSBAR& = CreateStatus($50000900 | $4000000, ADDR(Statustext$), %HWND, 2701)
    18. Dim Positions#, 20
    19. Long Positions#, 0 = 120
    20. Long Positions#, 4 = 240
    21. Long Positions#, 4 = 360
    22. Long Positions#, 8 = 480
    23. Long Positions#, 12 = 600
    24. Long Positions#, 16 = 720
    25. Sendmessage(STATUSBAR&, $404, 6, Positions#)
    26. Dispose Positions#
    27. Settimer 10
    28. LET ICONHANDLE& = $0
    29. Usermessages $10
    30. Clear X&, y&
    31. Count& = 5000
    32. While and(%Umessage <> $10, Count& > 0)
    33. Waitinput
    34. LET Statustext$ = Str$(ICONHANDLE&)
    35. sendmessage(Statusbar&, $401, 0, addr(Statustext$))
    36. sendmessage(Statusbar&, $410, 0, addr(Statustext$))
    37. IF (@GetIconInfo(ICONHANDLE&, IconInfo#)) = 1
    38. Count& = 5000
    39. @DrawIconEx(%HDC, x&, Y&, ICONHANDLE&, 20, 20, 0, brush&, 3)
    40. @DrawIconEx(%HDC2, x&, Y&, ICONHANDLE&, 20, 20, 0, brush&, 3)
    41. IF Erster% = 0
    42. LET Statustext$ = Str$(ICONHANDLE&)
    43. sendmessage(Statusbar&, $401, 1, addr(Statustext$))
    44. sendmessage(Statusbar&, $410, 1, addr(Statustext$))
    45. Let Erster% = 1
    46. endif
    47. LET Statustext$ = Str$(ICONHANDLE&)
    48. sendmessage(Statusbar&, $401, 2, addr(Statustext$))
    49. sendmessage(Statusbar&, $410, 2, addr(Statustext$))
    50. Let x& = X& + 21
    51. IF x& >= %MAXX - 40
    52. LET X& = 0
    53. Let Y& = Y& + 21
    54. endif
    55. endif
    56. LET Statustext$ = Str$(Int(ICONHANDLE& + $FFFE))
    57. sendmessage(Statusbar&, $401, 3, addr(Statustext$))
    58. sendmessage(Statusbar&, $410, 3, addr(Statustext$))
    59. IF (@GetIconInfo(ICONHANDLE& + $FFFE, IconInfo#)) = 1
    60. Count& = 5000
    61. @DrawIconEx(%HDC, x&, Y&, ICONHANDLE& + $FFFE, 20, 20, 0, brush&, 3)
    62. @DrawIconEx(%HDC2, x&, Y&, ICONHANDLE& + $FFFE, 20, 20, 0, brush&, 3)
    63. IF Erster2% = 0
    64. LET Statustext$ = Str$(Int(ICONHANDLE& + $FFFE))
    65. sendmessage(Statusbar&, $401, 4, addr(Statustext$))
    66. sendmessage(Statusbar&, $410, 4, addr(Statustext$))
    67. Let Erster2% = 1
    68. endif
    69. LET Statustext$ = Str$(Int(ICONHANDLE& + $FFFE))
    70. sendmessage(Statusbar&, $401, 5, addr(Statustext$))
    71. sendmessage(Statusbar&, $410, 5, addr(Statustext$))
    72. Let x& = X& + 21
    73. IF x& >= %MAXX - 40
    74. LET X& = 0
    75. Let Y& = Y& + 21
    76. endif
    77. endif
    78. Count& = Count& -1
    79. Let ICONHANDLE& = ICONHANDLE& + 1
    80. Wend
    81. Killtimer
    82. Dispose IconInfo#
    83. End
    84. Proc Positioner
    85. IF or(Hauptfensterbreite& <> WIDTH(%HWND), Hauptfensterhöhe& <> HEIGHT(%HWND))
    86. SetWindowPos Statusbar& = 0, 0 - 0, 0; 0
    87. LET Hauptfensterbreite& = WIDTH(%HWND)
    88. LET Hauptfensterhöhe& = HEIGHT(%HWND)
    89. endif
    90. endproc
    Alles anzeigen