DLL Datei Funktion



  • ich hoffe ich bin hier richtig, ansonsten einfach verschieben 😃

    naja also ich versuche im Moment eine .dll zu mache die die ich danach in eine .exe datei injizieren kann.

    wollte eigentlich nur fragen ob es eine Find Process By Name und Kill Process By Name funktion für dll datein gibt.

    ich arbeite imo mit paar freunden an nem kleinen online spiel und, naja wie bei jedem online spiel gibt es Cheater. will halt das die .dll datei es unterbindet z.b das sie bot.exe starten oder das er andere .dll datei löscht oder deaktiviert

    wäre schön wen mir das jemand weiter helfen könnte.



  • Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C++ (alle ISO-Standards) in das Forum WinAPI verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.



  • oh vielen dank



  • Nur um es klar zu bekommen:

    Du möchtest einen fremden Prozess aufgrund seines Namens erkennen und dann beenden?

    Ausserdem sollen nicht zum Projekt gehörige Dateien sowie veränderte Projektdateien erkannt und gelöscht werden?

    Diese Funktionen möchtest du in eine DLL auslagern? (Warum?)



  • genau ich möchte, fremde Prozess aufgrund seines Namens erkennen und dann beenden. in meinem game wird z.b autohotkay zum farmen benutzt, oder andre Programme die die in die Game.exe eine andere .dll datei injeziren. ich möchte es etwas in grenzen halten mit dieser .dll



  • Prozess finden:
    http://stackoverflow.com/questions/865152/how-can-i-get-a-process-handle-by-its-name-in-c

    Prozess beenden:
    http://stackoverflow.com/questions/1916574/how-to-effectively-kill-a-process-in-c-win32

    Aber ... ich halte deine Ansätze für sinnlos. Wenn ich ein böser Hacker/Cheater wäre und unbedingt diese autohotkay.exe nutzen wollen würde, um in deinem Spiel zu cheaten ... und dieser Prozess von deinem Programm immer wieder beendet wird.
    Wer hält mich denn davon ab, die "autohotkay.exe" in "autohotkey.exe" umzubenennen oder in etwas ganz anderes wie "avir_security.exe"? Im 2. Fall kannst du am Namen überhaupt nicht mehr erkennen, ob es ein böses Cheat Programm ist oder ob es evtl. gar ein, für den User, wichtiges Systemprogramm darstellt, dass seinen Rechner vor bösen Viren schützen soll.

    das er andere .dll datei löscht oder deaktiviert:
    naja ... wenn der User so blöd ist, deine DLLs zu löschen, kann er das Spiel halt einfach nicht starten, bzw. weiterspielen ... und was meinst du mit "deaktiviert"?!? Meinst du evtl. austauscht gegen eine veränderte DLL? Wenn ja ... dann überprüfe die Datei doch vorm laden einfach mittles MD5-Checksum oä.



  • hmn wo du es gerade sagst ist es mir auch auf Gefallen das es kaum etwas bringt, dar man ja einfach die cheating tools, .dll's umbenenne kann. wie löse ich das den sonst?

    besteht evtl. die Möglichkeit nach den Beschreibungs namen zu suchen und das Programm zu schließen?

    bild: http://www.fotos-hochladen.net/view/11qahjmueyz4.jpg



  • Für die eigenen Dateien eignet sich eine Prüfsumme.

    Bei fremden und somit unbekannten Dateien oder Prozessen kann sowohl die Prüfsumme alsauch die Beschreibung leicht geändert werden.

    Bei Dateien würde sich eine Art "VirenScanner" der nach Signaturen sucht evtl.
    anbieten.



  • hmn und wie bekommt man die Prüfsumme eine bestimmten datei raus?

    die meisten cheatin tools für mein Game kenne ich bereits, es werden auch kaum noch neue entwickelt, es sollte dann keine Problem sein sie alle runter zu laden und die Prüfsumme heraus zu bekommen, um es in die .dll einzufügen.

    ein beispiel wäre nicht schlecht. also es soll die Prüfsumme suchen und dann den Procces schließen. und garnicht mehr zulassen das er erneut gestartet werden kann.





  • okay habe allerdings eine anderes tool gefunden wollte mir dort keinen acc machen.

    diese toll findet die folgenden werte der Datei heraus.

    MD5 Checksum: 2EE7111F990AEDDC7524F87EABBBCB72
    SHA-1 Checksum: 88E962E56E5D755353B6B291F3A4E8284D213D2D
    SHA-256 Checksum: 2AAD3FEA228FF6FDA7B53F294BC2668A44B9507444EA617A539A194C009C4523
    SHA-512 Checksum: 853D1F523E6DC2BDA49FDC657E0F94E80718070D2FE9445112C2D47A3C5C91EC5A39A407EAEDA1AE096AE02A7F5A1B051BF816EF7BE99C865CAEC3F7335B1B54

    wäre nett wen jemand eine kleine Vorlage machen könnte



  • BTW: unter den allermeisten Linuxsystemen gibt es sowas sogar ganz ohne die Gefahr sich Vieren runterzuladen, oder sich überhaupt etwas zu installieren!



  • Google ist dein Freund!

    And again:
    http://lmgtfy.com/?q=c%2B%2B+md5+file

    Die Ergebnisse der Suche beinhalten auch andere Seiten, auf denen man sich nicht extra anmelden muss. So z.B.:

    https://msdn.microsoft.com/en-us/library/windows/desktop/aa382380%28v=vs.85%29.aspx



  • habe doch geschrieben das ich bereits eine Tool gefunden habe.

    wollte eigentlich eine Vorlage wie man z.b den MD5 wert, sucht und dann mit TerminateProcess den Process schließen tut



  • MD5 musst du errechnen, nicht suchen und finden. Hier mal Code zum errechen von MD5:

    md5.h

    typedef unsigned int	MD5_u32plus;
    
    typedef struct{
    	MD5_u32plus		lo, hi;
    	MD5_u32plus		a, b, c, d;
    	unsigned char		buffer[64];
    	MD5_u32plus		block[16];
    }MD5_CTX;
    
    //md5.c
    //====================
     void		MD5_CreateChecksum(u_char *buffer, u_long len_buffer, u_char checksum[16]);
    

    md5.c

    #include "_precompiled.h"
    #include "md5.h"
    
    #define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))
    #define G(x, y, z)			((y) ^ ((z) & ((x) ^ (y))))
    #define H(x, y, z)			((x) ^ (y) ^ (z))
    #define I(x, y, z)			((y) ^ ((x) | ~(z)))
    
    #define STEP(f, a, b, c, d, x, t, s) 	(a) += f((b), (c), (d)) + (x) + (t); (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); (a) += (b);
    
    #if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
    	#define SET(n)		(*(MD5_u32plus *)&ptr[(n) * 4])
    	#define GET(n) 		SET(n)
    #else
    	#define SET(n)		(ctx->block[(n)] = (MD5_u32plus)ptr[(n) * 4] | ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
    	#define GET(n)		(ctx->block[(n)])
    #endif
    
    /*
    ===============================================================================
    MD5_Body
    
    ===============================================================================
    */
    static void *MD5_Body(MD5_CTX *ctx, void *data, unsigned long size){
    
    	unsigned char		*ptr;
    	MD5_u32plus		a, b, c, d;
    	MD5_u32plus		saved_a, saved_b, saved_c, saved_d;
    
    	ptr = data;
    	a = ctx->a;
    	b = ctx->b;
    	c = ctx->c;
    	d = ctx->d;
    	do{
    		saved_a = a;
    		saved_b = b;
    		saved_c = c;
    		saved_d = d;
    
    /* Round 1 */
    		STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
    		STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
    		STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
    		STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
    		STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
    		STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
    		STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
    		STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
    		STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
    		STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
    		STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
    		STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
    		STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
    		STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
    		STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
    		STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
    
    /* Round 2 */
    		STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
    		STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
    		STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
    		STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
    		STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
    		STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
    		STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
    		STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
    		STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
    		STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
    		STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
    		STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
    		STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
    		STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
    		STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
    		STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
    
    /* Round 3 */
    		STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
    		STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
    		STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
    		STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)
    		STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
    		STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)
    		STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
    		STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)
    		STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
    		STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)
    		STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
    		STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)
    		STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
    		STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)
    		STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
    		STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)
    
    /* Round 4 */
    		STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
    		STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
    		STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
    		STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
    		STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
    		STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
    		STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
    		STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
    		STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
    		STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
    		STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
    		STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
    		STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
    		STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
    		STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
    		STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
    
    		a += saved_a;
    		b += saved_b;
    		c += saved_c;
    		d += saved_d;
    
    		ptr += 64;
    	}while (size -= 64);
     	ctx->a = a;
    	ctx->b = b;
    	ctx->c = c;
    	ctx->d = d;
     	return ptr;
    }
    
     /*
    ===============================================================================
    MD5_Init
    
    ===============================================================================
    */
    void MD5_Init(MD5_CTX *ctx){
    
    	ctx->a = 0x67452301;
    	ctx->b = 0xefcdab89;
    	ctx->c = 0x98badcfe;
    	ctx->d = 0x10325476;
     	ctx->lo = 0;
    	ctx->hi = 0;
    }
    
    /*
    ===============================================================================
    MD5_Update
    
    ===============================================================================
    */
     void MD5_Update(MD5_CTX *ctx, unsigned char *data, unsigned long size){
    
    	MD5_u32plus		saved_lo;
    	unsigned long		used, free;
    
    	saved_lo = ctx->lo;
    	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo){
    		ctx->hi++;
    	}
    	ctx->hi += size >> 29;
    	used = saved_lo & 0x3f;
     	if(used){
    		free = 64 - used;
     		if (size < free) {
    			memcpy(&ctx->buffer[used], data, size);
    			return;
    		}
     		memcpy(&ctx->buffer[used], data, free);
    		data = (unsigned char *)data + free;
    		size -= free;
    		MD5_Body(ctx, ctx->buffer, 64);
    	}
     	if (size >= 64) {
    		data = MD5_Body(ctx, data, size & ~(unsigned long)0x3f);
    		size &= 0x3f;
    	}
     	memcpy(ctx->buffer, data, size);
    }
    
    /*
    ===============================================================================
    MD5_Final
    
    ===============================================================================
    */
     void MD5_Final(unsigned char *result, MD5_CTX *ctx){
    
    	unsigned long		used, free;
    
    	used = ctx->lo & 0x3f;
    	ctx->buffer[used++] = 0x80;
    	free = 64 - used;
    	if(free < 8) {
    		memset(&ctx->buffer[used], 0, free);
    		MD5_Body(ctx, ctx->buffer, 64);
    		used = 0;
    		free = 64;
    	}
    	memset(&ctx->buffer[used], 0, free - 8);
    	ctx->lo <<= 3;
    	ctx->buffer[56] = ctx->lo;
    	ctx->buffer[57] = ctx->lo >> 8;
    	ctx->buffer[58] = ctx->lo >> 16;
    	ctx->buffer[59] = ctx->lo >> 24;
    	ctx->buffer[60] = ctx->hi;
    	ctx->buffer[61] = ctx->hi >> 8;
    	ctx->buffer[62] = ctx->hi >> 16;
    	ctx->buffer[63] = ctx->hi >> 24;
     	MD5_Body(ctx, ctx->buffer, 64);
     	result[0] = ctx->a;
    	result[1] = ctx->a >> 8;
    	result[2] = ctx->a >> 16;
    	result[3] = ctx->a >> 24;
    	result[4] = ctx->b;
    	result[5] = ctx->b >> 8;
    	result[6] = ctx->b >> 16;
    	result[7] = ctx->b >> 24;
    	result[8] = ctx->c;
    	result[9] = ctx->c >> 8;
    	result[10] = ctx->c >> 16;
    	result[11] = ctx->c >> 24;
    	result[12] = ctx->d;
    	result[13] = ctx->d >> 8;
    	result[14] = ctx->d >> 16;
    	result[15] = ctx->d >> 24;
     	memset(ctx, 0, sizeof(*ctx));
    }
    
    /*
    ===============================================================================
    MD5_CreateChecksum
    
    ===============================================================================
    */
    void MD5_CreateChecksum(u_char *buffer, u_long len_buffer, u_char checksum[16]){
    
    	MD5_CTX		ctx;
    
    	MD5_Init(&ctx);
    	MD5_Update(&ctx, buffer, len_buffer);
    	MD5_Final(checksum, &ctx);
    }
    

Anmelden zum Antworten