ich habe mir neulich das Buch "Gray Hat Python" von Justin Seitz (der übrigends nirgendwo per email zu erreichen ist, sonst hätte ich den mal gefagt) gekauft.
Leider stecke ich bei Seite 32-33 schon fest weil das script nicht so funktioniert wie es sollte.Es handlet sich dabei um einen Debugger für Windows.Der Autor hat zwar einige updates auf No Starch Press gepostet http://nostarch.com/ghpython.htm aber die Zeile ,die ich z.B. auf Seite 33 entfernen soll "In function attach(): remove the self.run()" gibt es im script nicht
Der debugger besteht aus drei teilen:
my_debugger_defines.py indem die Windows types nach ctypes definiert werden
my_debugger.py der eigentliche debugger
my_test.py damit startet man das ganze.
Das Problem ist, dass nachdem ich my_test.py gestartet habe ,calc.exe gestartet habe und den PID von calc.exe im DOS prompt eingegeben habe, erscheint nur die Meldung: Finished debugging.Exiting...
Es sollte aber eingentlich:Please press a key to continue erscheinen und erst nachdem eine Taste gedrückt wurde die obige Meldung.
Ausserdem dürfte dann calc.exe nicht mehr reagieren bis ich eine Taste gedrückt habe.
Vielleicht könnt Ihr mir einen Tip geben :K
my_debugger_defines:
Code: Alles auswählen
#!/usr/bin/python
from ctypes import *
WORD = c_ushort
DWORD = c_ulong
LPBYTE = POINTER(c_ubyte)
LPTSTR = POINTER(c_char)
HANDLE = c_void_p
# Constants
DEBUG_PROCESS = 0x00000001
CREATE_NEW_CONSOLE = 0x00000010
# Structures for CreateProcessA() function
class STARTUPINFO(Structure):
_fields_ = [
("cb", DWORD),
("lpReserved", LPTSTR),
("lpDesktop", LPTSTR),
("lpTitle", LPTSTR),
("dwX", DWORD),
("dwY", DWORD),
("dwXSize", DWORD),
("dwYSize", DWORD),
("dwXCountChars", DWORD),
("dwYCountChars", DWORD),
("dwFillAttribute", DWORD),
("dwFlags", DWORD),
("wShowWindow", WORD),
("cbReserved2", WORD),
("lpReserved2", LPBYTE),
("hStdInput", HANDLE),
("hStdOutput", HANDLE),
("hStdError", HANDLE),
]
class PROCESS_INFORMATION(Structure):
_fields_ = [
("hProcess", HANDLE),
("hThread", HANDLE),
("dwProcessId", DWORD),
("dwThreadId", DWORD),
]
Code: Alles auswählen
#!/usr/bin/python
from ctypes import *
from my_debugger_defines import *
kernel32 = windll.kernel32
class debugger():
def _init_(self):
self.h_process = None
self.pid = None
self.debugger_active = False
def load(self,path_to_exe):
# dwCreation flag determines how to create the process
# set creation_flags = CREATE_NEW_CONSOLE if you want
# to see the calculator GUI
creation_flags = DEBUG_PROCESS
# instantiate the structs
startupinfo = STARTUPINFO()
process_information = PROCESS_INFORMATION()
# The following two options allow the started process
# to be shown as a separate window. This also illustrates
# how different settings in the STARTUPINFO struct can affect
# the debugger
startupinfo.dwFlags = 0x1
startupinfo.wShowWindow = 0x0
# We then initialize the cb variable in the STARTUPINFO struct
# which is just the size of the struct itself
startupinfo.cb = sizeof(startupinfo)
if kernel32.CreateProcessA(path_to_exe,
None,
None,
None,
None,
creation_flags,
None,
None,
byref(startupinfo),
byref(process_information)):
print "[*] We have successfully launched the process!"
print "[*] PID: %d" % process_information.dwProcessId
# Obtain a valid handle to the newly created process
# and store it for future access
self.h_process = self.open_process(process_information.dwProcessId)
else:
print "[*] Error: 0x%08x." % kernel32.GetLastError()
def open_process(self,pid):
h_process = kernel32.OpenProcess(PROCESS_ALL_ACCESS,False,pid)
return h_process
def attach(self,pid):
self.h_process = self.open_process(pid)
# We attempt to attach to the process
# if this fails, we exit the call
if kernel32.DebugActiveProcess(pid):
self.debugger_active = True
self.pid = int(pid)
else:
print "[*] Unable to attach to the process."
def run(self):
# Now we have to poll the debugger for
# debugging events
while self.debugger_active == True:
self.get_debug_event()
def get_debug_event(self):
debug_event = DEBUG_EVENT()
continue_status = DBG_CONTINUE
if kernel32.WaitForDebugEvent(byref(debug_event),INFINITE):
# We are not going to build any event handlers just yet
# Let us just resume the process for now
raw_input("Press a key to continue...")
self.debugger_active = False
kernel32.ContinueDebugEvent( \
debug_event.dwProcessId, \
debug_event.dwThreadId, \
continue_status )
def detach(self):
if kernel32.DebugActiveProcessStop(self.pid):
print "[*] Finished debugging.Exiting..."
return True
else:
print "There was an Error"
return false
Code: Alles auswählen
#!/usr/bin/python
import my_debugger
debugger = my_debugger.debugger()
pid = raw_input("Enter the PID of the process to attach to: ")
debugger.attach(int(pid))
debugger.detach()
Ich glaube der Fehler liegt in der Attach funktion weil der debugger sich nicht an calc.exe hängt.
Wäre schön wenn Ihr mal drüber gucken und mir einen Hinweis geben könntet.
Schönen Tag wünscht
patzen