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

Log in to reply