Keylogger



  • Hallo, ich würde gerne einen Keylogger schreiben.
    Bevor hier irgendwer sagt "Hör auf mit dem Scheiß, gehört nicht hier her":
    Ich will den nur auf meinem System ausführen, ich respektiere die Privatsphäre anderer und das Programm darf bei Systemstart schreien "Hallo, hier bin ich". Auch bei den Prozessen soll man es finden.
    Das ganze soll aber nicht permanent eine Konsole blockieren, wie z.b. wenn man "vlc" in der Konsole eingibt, vlc gestartet wird und die Konsole permanent offen bleiben muss. eher wie sudo /etc/init.d/apache2 start
    und wie kann ich direkt die tastatureingabe abfragen? das scheint mir sehr hardwarenahe zu sein...
    schreiben wollte ich das ganze mit c++ und qt (signale / slots für keypressed)
    ich würde das ja mit QKeyEvent oder QWidget::keyPressEvent() machen, bei denen braucht mein Programm aber den Focus. Mein Programm soll aber im hintergrund laufen...
    Funktioniert es evtl. mit QWidget::grabKeyboard()

    Gruß,
    Daniel



  • Hey, ich hab jetzt schon mal was programmiert:
    das Programm benötigt jedoch den Focus.
    Ansonsten macht es das, was es soll...
    Hier mal der bisherige Code:
    main.cpp:

    #include "keygrabber.h"
    
    int main(int argc, char *argv[])
    {
    	QApplication app(argc, argv);
    	keygrabber blub;
    	blub.resize(200, 1);
    	blub.show();
    
    	//QObject::connect(blub.abbrechen, SIGNAL(clicked()), &app, SLOT(quit()));
    
    	return app.exec();
    }
    

    keygrabber.h:

    #ifndef KEYGRABBER_H
    #define KEYGRABBER_H
    
    #include <QApplication>		//					QT
    #include <QWidget>		//					QT
    #include <QKeyEvent>		//					QT
    
    #include <fstream>		//ofstream			C++
    
    class keygrabber : public QWidget
    {
    	public:
    		keygrabber(QWidget *parent = 0);
    
    		int taste_pressed[2];
    		bool sonderzeichen_b;
    		std::string sonderzeichen;
    
    		char itoc(int taste_i);
    		void schreiben(char taste_c);
    		void eintragen(int taste_i);
    
    	protected:
    		virtual void keyPressEvent(QKeyEvent *event);
    		virtual void keyReleaseEvent(QKeyEvent *event);
    };
    
    #endif
    

    keygrabber.cpp:

    #include "keygrabber.h"
    
    keygrabber::keygrabber(QWidget *parent)
        : QWidget(parent)
    {
    	for (int i=0; i<2; i++){taste_pressed[i] = -1;}
    }
    
    void keygrabber::keyPressEvent(QKeyEvent *event)
    {
    	int taste_i;
    	taste_i = event->key();
    	eintragen(taste_i);
    	char taste_c;
    	taste_c = itoc(taste_i);
    	schreiben(taste_c);
    }
    
    void keygrabber::eintragen(int taste_i)//traegt gedrueckte tasten in das array taste_pressed[] ein; es duerfen max. 2 tasten gleichzeitig gedrueckt werden; fuer shift benoetigt
    {
    	for (int i=0; i<2; i++)
    	{
    		if (taste_pressed[i] == -1)
    		{
    			taste_pressed[i] = taste_i;
    			return;
    		}
    	}
    }
    
    char keygrabber::itoc(int taste_i)//korrigiert A zu a und konvertiert das char zu int; sonderzeichen werden anders geschrieben
    {
    	if ((taste_i >=32)&&(taste_i <=126))//nur lesbare zeichen
    	{
    		bool shift=false, altgr=false;
    		for (int i=0; i<2; i++)
    		{
    			if (taste_pressed[i] == 16777248){shift = true;}
    			if (taste_pressed[i] == 16781571){altgr = true;}
    		}
    		sonderzeichen_b = false;
    		if (true)//if (altgr == false)
    		{
    			if ((taste_i >= 65)&&(taste_i <= 90))
    			{
    				if (shift == false)
    				{
    					taste_i += 32;//grosse buchstaben aber kein shift!
    				}
    			}
    			if ((taste_i >= 97)&&(taste_i <= 122))
    			{
    				if (shift == true)
    				{
    					taste_i -= 32;//kleine buchstaben trotz shift!
    				}
    			}
    		}
    		else//if (altgr == true)
    		{
    
    		}
    		char taste_c;
    		taste_c = (char) taste_i;
    		return taste_c;
    	}
    	else
    	{
    		sonderzeichen_b = true;
    		switch (taste_i)
    		{
    			case 16777223:
    				sonderzeichen = "[DELETE]";
    				return '\0';
    			case 16777219:
    				sonderzeichen = "[BACKSPACE]";
    				return '\0';
    			case 16777220:
    				sonderzeichen = "[ENTER]";
    				return '\0';
    			case 16777217:
    				sonderzeichen = "[TABULATOR]";
    				return '\0';
    		}
    	}
    	return '\0';
    }
    
    void keygrabber::schreiben(char taste_c)//schreibt die keygeloggten daten in eine datei
    {
    	std::ofstream write;
    	write.open("keylog.txt", std::ios_base::out|std::ios_base::app);
    	if (sonderzeichen_b == false){write << taste_c;}
    	else {write << sonderzeichen;}
    	write.close();
    }
    
    void keygrabber::keyReleaseEvent(QKeyEvent *event)//traegt die zeichen wieder aus dem array taste_pressed[] aus
    {
    	for (int i=0; i<2; i++)
    	{
    		if (taste_pressed[i] == event->key()){taste_pressed[i] = -1;}
    	}
    }
    


  • Greifs doch direkt vom Inputdevice ab, oder aber via die X11 Library, o.ä. du hast ja nach bevor das an die Snwendungen geht den x11 Mapper davor, der die Shortcuts bindet und außerdem Sondertastenfunktionalitäten bietet. Einfach mal schaun wie man das benutzt, dort sollte man dann ansetzen oder wie gesagt, den RAW-Input vom Keyb. abfangen indem du am Device Block der Tastatur mitliest.


Log in to reply