STRLCPY/obfus.h

Improved anti-decompiler
DosX committed with GitHub 1 month ago

8803be07

1 parent d973a441

Total 1 files

■ ■ ■ ■ ■ ■

include/obfus.h

		skipped 25 lines
26	26		// Thanks to @horsicq && @ac3ss0r
27	27		#define RND(min, max) (min + (((__COUNTER__ + (__LINE__ * __LINE__)) * 2654435761u) % (max - min + 1)))
28	28
29		-	#define BREAK_STACK \
30		-	asm __volatile("xorl %eax, %eax"); \
31		-	asm __volatile("jz 1f"); \
32		-	asm __volatile(".byte 0x00"); \
33		-	asm __volatile("1:");
	29	+	#define BREAK_STACK_1 \
	30	+	__asm__ __volatile("xorl %eax, %eax"); \
	31	+	__asm__ __volatile("jz 1f"); \
	32	+	__asm__ __volatile(".byte 00"); \
	33	+	__asm__ __volatile("1:");
	34	+
	35	+	#define BREAK_STACK_2 \
	36	+	if (_0) __asm__(".byte 00");
	37	+
	38	+	#define BREAK_STACK_3 \
	39	+	switch (_0) { \
	40	+	case 1: \
	41	+	__asm__(".byte 00"); \
	42	+	}
34	43
35	44		void junkFunc(int z, ...) {
36		-	BREAK_STACK;
	45	+	BREAK_STACK_1;
37	46		__asm__ __volatile("nop");
38	47		return;
39	48		}
40	49
41	50		void junkFuncEmpty() {
42		-	BREAK_STACK;
	51	+	BREAK_STACK_1;
43	52		__asm__ __volatile("nop");
44	53		return;
45	54		}
		skipped 41 lines
87	96		} while (RND(0, 200) * _0)
88	97
89	98		int malloc_Proxy(int *size) {
90		-	BREAK_STACK;
	99	+	BREAK_STACK_1;
91	100		return malloc(size);
92	101		}
93	102		#define malloc(...) malloc_Proxy(__VA_ARGS__)
		skipped 1 lines
95	104		static char rndValueToProxy = RND(0, 10);
96	105
97	106		int int_Proxy(int value) {
98		-	BREAK_STACK;
	107	+	BREAK_STACK_1;
99	108		if (rndValueToProxy == value)
100	109		return rndValueToProxy;
101	110
		skipped 5 lines
107	116		}
108	117
109	118		double double_Proxy(double value) {
110		-	BREAK_STACK;
	119	+	BREAK_STACK_1;
111	120		junkFunc(RND(0, 1000), RND(0, 1000));
112	121		FAKE_CPUID;
113	122		return (value * _1);
114	123		}
115	124
116	125		int condition_True() {
117		-	BREAK_STACK;
	126	+	BREAK_STACK_1;
118	127		FAKE_CPUID;
119	128		return _1 && TRUE;
120	129		}
121	130
122	131		int condition_Proxy(int junk, int condition) {
123		-	BREAK_STACK;
	132	+	BREAK_STACK_1;
124	133
125	134		int result = int_Proxy(condition * _1);
126	135		if (result == (FALSE * junk)) {
		skipped 10 lines
137	146
138	147		#define if(condition) if ((RND(0, 1000)) > _0 && (RND(2, 1000) > condition_True() && condition_Proxy(RND(0, 1000000), condition) && RND(1, 9999999999) > _0 && (int_Proxy(RND(0, 1000)) < RND(1001, 100000000))))
139	148		#define else \
140		-	else if (_0 > RND(0, 1000)) { \
	149	+	else if (_0 > RND(1, 1000)) { \
141	150		junkFunc(RND(0, 1000)); \
	151	+	__asm__ __volatile(".byte 0x3C, 00"); \
142	152		} \
143	153		else if (RND(0, 10) == (RND(11, 100))) { \
144	154		int_Proxy(_3 - RND(0, 10000)); \
145	155		} \
146	156		else if (FALSE * RND(0, 1000)) { \
147		-	BREAK_STACK; \
	157	+	BREAK_STACK_1; \
148	158		} \
149	159		else if (FALSE * (int_Proxy(RND(0, 1000)) ? RND(1, 99999999) : RND(1, 99999999))) { \
150	160		NOP_FLOOD; \
		skipped 6 lines
157	167		#endif
158	168
159	169		char *getCharMask(int count) {
160		-	BREAK_STACK;
	170	+	BREAK_STACK_1;
161	171		static char mask[16];
162	172		if (count <= _0 \|\| count >= sizeof(mask)) {
163	173		return NULL;
164	174		}
165	175		int i = (((_1 * _5) - _4) + _1) - _2;
166		-	BREAK_STACK;
	176	+	BREAK_STACK_1;
167	177		char *ptr = mask;
168	178		for (i = _0; i < count; i++) {
169	179		*ptr++ = '%';
		skipped 7 lines
177	187
178	188		// WriteConsoleA
179	189		BOOL WriteConsoleA_Proxy(HANDLE hConsoleOutput, const void *lpBuffer, DWORD nNumberOfCharsToWrite, LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved) {
180		-	BREAK_STACK;
	190	+	BREAK_STACK_1;
181	191		FAKE_CPUID;
182	192		return WriteConsoleA(hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved);
183	193		}
		skipped 1 lines
185	195
186	196		// GetStdHandle
187	197		HANDLE GetStdHandle_Proxy(DWORD nStdHandle) {
188		-	BREAK_STACK;
	198	+	BREAK_STACK_1;
189	199		FAKE_CPUID;
190	200		return GetStdHandle(int_Proxy(nStdHandle));
191	201		}
		skipped 1 lines
193	203
194	204		// GetProcAddress
195	205		FARPROC GetProcAddress_Proxy(HMODULE hModule, LPCSTR lpProcName) {
196		-	BREAK_STACK;
	206	+	BREAK_STACK_1;
197	207		FAKE_CPUID;
198	208		return GetProcAddress(hModule, lpProcName);
199	209		}
200	210		#define GetProcAddress(...) GetProcAddress_Proxy(__VA_ARGS__)
201	211
202	212		HMODULE GetModuleHandleA_Proxy(LPCSTR lpModuleName) {
203		-	BREAK_STACK;
	213	+	BREAK_STACK_1;
204	214		FAKE_CPUID;
205	215		return GetModuleHandleA(lpModuleName);
206	216		}
		skipped 1 lines
208	218
209	219		// strcmp
210	220		int strcmp_custom(const char str1, const char str2) {
211		-	BREAK_STACK;
	221	+	BREAK_STACK_1;
212	222		while (str1 != '\0' \|\| str2 != '\0') {
213	223		NOP_FLOOD;
214	224		if ((int_Proxy(str1) < int_Proxy(str2)) && int_Proxy(_1)) {
		skipped 11 lines
226	236
227	237		// strlen
228	238		size_t strlen_custom(const char *str) {
229		-	BREAK_STACK;
	239	+	BREAK_STACK_1;
230	240		size_t length = _0;
231	241		while (*str != '\0') {
232	242		length += int_Proxy(_1);
		skipped 27 lines
260	270
261	271		static char loadStr[5];
262	272		HMODULE LoadLibraryA_0(LPCSTR lpLibFileName) {
263		-	BREAK_STACK;
	273	+	BREAK_STACK_1;
264	274		// return LoadLibraryA(lpLibFileName);
265	275
266	276		typedef HMODULE(WINAPI * LoadLibraryAFunc)(LPCSTR);
		skipped 22 lines
289	299		}
290	300		}
291	301		if (loadLibraryA != NULL) {
292		-	BREAK_STACK;
	302	+	BREAK_STACK_1;
293	303		return loadLibraryA(lpLibFileName);
294	304		}
295	305		return NULL;
296	306		}
297	307
298	308		char *LoadLibraryA_1(LPCSTR lpLibFileName) {
299		-	BREAK_STACK;
	309	+	BREAK_STACK_1;
300	310		return LoadLibraryA_0((LPCSTR)lpLibFileName);
301	311		}
302	312		char *LoadLibraryA_2(LPCSTR lpLibFileName) {
303		-	BREAK_STACK;
	313	+	BREAK_STACK_1;
304	314		return LoadLibraryA_1((LPCSTR)lpLibFileName);
305	315		}
306	316		char *LoadLibraryA_3(LPCSTR lpLibFileName) {
307		-	BREAK_STACK;
	317	+	BREAK_STACK_1;
308	318		return LoadLibraryA_2((LPCSTR)lpLibFileName);
309	319		}
310	320		char *LoadLibraryA_4(LPCSTR lpLibFileName) {
311		-	BREAK_STACK;
	321	+	BREAK_STACK_1;
312	322		return LoadLibraryA_3((LPCSTR)lpLibFileName);
313	323		}
314	324		char *LoadLibraryA_5(LPCSTR lpLibFileName) {
315		-	BREAK_STACK;
	325	+	BREAK_STACK_1;
316	326		return LoadLibraryA_4((LPCSTR)lpLibFileName);
317	327		}
318	328		char *LoadLibraryA_Proxy(LPCSTR lpLibFileName) {
319		-	BREAK_STACK;
	329	+	BREAK_STACK_1;
320	330		return LoadLibraryA_5((LPCSTR)lpLibFileName);
321	331		}
322	332		#define LoadLibraryA(...) LoadLibraryA_Proxy(__VA_ARGS__)
323	333
324	334		#if !defined(no_antidebug) && no_antidebug != 1
325	335		int IsDebuggerPresent_Proxy() {
326		-	BREAK_STACK;
	336	+	BREAK_STACK_2;
327	337		NOP_FLOOD;
328	338		#if defined hide_antidebug
329	339		char result[32];
		skipped 28 lines
358	368		}
359	369
360	370		void crash() {
361		-	BREAK_STACK;
	371	+	BREAK_STACK_1;
362	372		__asm__("int $3");
363	373		}
364	374
365	375		#define ANTI_DEBUG \
366	376		if (IsDebuggerPresent() \|\| int_Proxy(_0 / !IsDebuggerPresent_Proxy() * (_1 + _0 + _1) / _2)) { \
367		-	BREAK_STACK; \
	377	+	BREAK_STACK_1; \
368	378		crash(); \
369	379		__asm__("int $3"); \
370	380		_0 / _0; \
		skipped 10 lines
381	391		#endif
382	392
383	393		char *getStdLibName() {
384		-	BREAK_STACK;
	394	+	BREAK_STACK_1;
385	395		NOP_FLOOD;
386	396		junkFunc(_0 + _3);
387	397		junkFunc(_3 - _2);
		skipped 15 lines
403	413		}
404	414
405	415		char *getStdLibName_1() {
406		-	BREAK_STACK;
	416	+	BREAK_STACK_1;
407	417		return getStdLibName();
408	418		}
409	419		char *getStdLibName_2() {
410		-	BREAK_STACK;
	420	+	BREAK_STACK_1;
411	421		return getStdLibName_1();
412	422		}
413	423		char *getStdLibName_3() {
414		-	BREAK_STACK;
	424	+	BREAK_STACK_1;
415	425		return getStdLibName_2();
416	426		}
417	427		char *getStdLibName_4() {
418		-	BREAK_STACK;
	428	+	BREAK_STACK_1;
419	429		return getStdLibName_3();
420	430		}
421	431		char *getStdLibName_5() {
422		-	BREAK_STACK;
	432	+	BREAK_STACK_1;
423	433		return getStdLibName_4();
424	434		}
425	435		char *getStdLibName_6() {
426		-	BREAK_STACK;
	436	+	BREAK_STACK_1;
427	437		return getStdLibName_5();
428	438		}
429	439		char *getStdLibName_7() {
430		-	BREAK_STACK;
	440	+	BREAK_STACK_1;
431	441		return getStdLibName_6();
432	442		}
433	443		char *getStdLibName_8() {
434		-	BREAK_STACK;
	444	+	BREAK_STACK_1;
435	445		return getStdLibName_7();
436	446		}
437	447		char *getStdLibName_9() {
438		-	BREAK_STACK;
	448	+	BREAK_STACK_1;
439	449		return getStdLibName_8();
440	450		}
441	451		char *getStdLibName_10() {
442		-	BREAK_STACK;
	452	+	BREAK_STACK_1;
443	453		return getStdLibName_9();
444	454		}
445	455		char *getStdLibName_11() {
446		-	BREAK_STACK;
	456	+	BREAK_STACK_1;
447	457		return getStdLibName_10();
448	458		}
449	459		char *getStdLibName_12() {
450		-	BREAK_STACK;
	460	+	BREAK_STACK_1;
451	461		return getStdLibName_11();
452	462		}
453	463		char *getStdLibName_13() {
454		-	BREAK_STACK;
	464	+	BREAK_STACK_1;
455	465		return getStdLibName_12();
456	466		}
457	467		char *getStdLibName_14() {
458		-	BREAK_STACK;
	468	+	BREAK_STACK_1;
459	469		return getStdLibName_13();
460	470		}
461	471		char *getStdLibName_15() {
462		-	BREAK_STACK;
	472	+	BREAK_STACK_1;
463	473		return getStdLibName_14();
464	474		}
465	475		char *getStdLibName_16() {
466		-	BREAK_STACK;
	476	+	BREAK_STACK_1;
467	477		return getStdLibName_15();
468	478		}
469	479		char *getStdLibName_Proxy() {
470		-	BREAK_STACK;
	480	+	BREAK_STACK_1;
471	481		return getStdLibName_16();
472	482		}
473	483
474	484		// printf
475	485		void printf_custom(int junk, const char *format, ...) {
476		-	BREAK_STACK;
	486	+	BREAK_STACK_1;
477	487		char buffer[1024];
478	488		va_list args;
479	489		NOP_FLOOD;
		skipped 9 lines
489	499		// printf as void
490	500		#define printf(...) \
491	501		do { \
492		-	BREAK_STACK; \
	502	+	BREAK_STACK_1; \
493	503		ANTI_DEBUG; \
494	504		junkFunc((RND(0, 1000) * 3) < _0); \
495	505		printf_custom(RND(0, 1000), __VA_ARGS__); \
		skipped 1 lines
497	507
498	508		// scanf
499	509		char *getScanfName_Proxy() {
500		-	BREAK_STACK;
	510	+	BREAK_STACK_1;
501	511		FAKE_CPUID;
502	512		return "scanf";
503	513		// return ({ char result[32]; sprintf(result, getCharMask(_5), _s, _c, _a, _n, _f); result; });
		skipped 2 lines
506	516
507	517		// sprintf
508	518		char *getSprintfName_Proxy() {
509		-	BREAK_STACK;
	519	+	BREAK_STACK_1;
510	520		FAKE_CPUID;
511	521		return "sprintf";
512	522		// return ({ char result[32]; sprintf(result, getCharMask(_7), _s, _p, _r, _i, _n, _t, _f); result; });
		skipped 2 lines
515	525
516	526		// fclose
517	527		char *getFcloseName_Proxy() {
518		-	BREAK_STACK;
	528	+	BREAK_STACK_1;
519	529		FAKE_CPUID;
520	530		return "fclose";
521	531		// return ({ char result[32]; sprintf(result, getCharMask(_6), _f, _c, _l, _o, _s, _e); result; });
		skipped 2 lines
524	534
525	535		// fopen
526	536		char *getFopenName_Proxy() {
527		-	BREAK_STACK;
	537	+	BREAK_STACK_1;
528	538		FAKE_CPUID;
529	539		return "fopen";
530	540		// return ({ char result[32]; sprintf(result, getCharMask(_5), _f, _o, _p, _e, _n); result; });
		skipped 2 lines
533	543
534	544		// fread
535	545		char *getFreadName_Proxy() {
536		-	BREAK_STACK;
	546	+	BREAK_STACK_1;
537	547		FAKE_CPUID;
538	548		return "fread";
539	549		// return ({ char result[32]; sprintf(result, getCharMask(_5), _f, _r, _e, _a, _d); result; });
		skipped 2 lines
542	552
543	553		// fwrite
544	554		char *getFwriteName_Proxy() {
545		-	BREAK_STACK;
	555	+	BREAK_STACK_1;
546	556		FAKE_CPUID;
547	557		return "fwrite";
548	558		// return ({ char result[32]; sprintf(result, getCharMask(_6), _f, _w, _r, _i, _t, _e); result; });
		skipped 2 lines
551	561
552	562		// exit
553	563		char *getExitName_Proxy() {
554		-	BREAK_STACK;
	564	+	BREAK_STACK_1;
555	565		FAKE_CPUID;
556	566		return "exit";
557	567		// return ({ char result[32]; sprintf(result, getCharMask(_4), _e, _x, _i, _t); result; });
		skipped 2 lines
560	570
561	571		// strcpy
562	572		char *getStrcpyName_Proxy() {
563		-	BREAK_STACK;
	573	+	BREAK_STACK_1;
564	574		FAKE_CPUID;
565	575		return "strcpy";
566	576		// return ({ char result[32]; sprintf(result, getCharMask(_6), _s, _t, _r, _c, _p, _y); result; });
		skipped 2 lines
569	579
570	580		// strtok
571	581		char *getStrtokName_Proxy() {
572		-	BREAK_STACK;
	582	+	BREAK_STACK_1;
573	583		FAKE_CPUID;
574	584		return "strtok";
575	585		// return ({ char result[32]; sprintf(result, getCharMask(_6), _s, _t, _r, _t, _o, _k); result; });
		skipped 2 lines
578	588
579	589		// memset
580	590		void memset_Proxy(void ptr, int value, size_t num) {
581		-	BREAK_STACK;
	591	+	BREAK_STACK_1;
582	592		return memset(ptr, value * _1, num);
583	593		}
584	594		#define memset(...) memset_Proxy(__VA_ARGS__)
585	595
586	596		// memcpy
587	597		char *getMemcpyName_Proxy() {
588		-	BREAK_STACK;
	598	+	BREAK_STACK_1;
589	599		FAKE_CPUID;
590	600		return "memcpy";
591	601		// return ({ char result[32]; sprintf(result, getCharMask(_6), _m, _e, _m, _c, _p, _y); result; });
		skipped 2 lines
594	604
595	605		// strchr
596	606		char *getStrchrName_Proxy() {
597		-	BREAK_STACK;
	607	+	BREAK_STACK_1;
598	608		FAKE_CPUID;
599	609		return "strchr";
600	610		// return ({ char result[32]; sprintf(result, getCharMask(_6), _s, _t, _r, _c, _h, _r); result; });
		skipped 2 lines
603	613
604	614		// strrchr
605	615		char *getStrrchrName_Proxy() {
606		-	BREAK_STACK;
	616	+	BREAK_STACK_1;
607	617		FAKE_CPUID;
608	618		return "strrchr";
609	619		// return ({ char result[32]; sprintf(result, getCharMask(_7), _s, _t, _r, _r, _c, _h, _r); result; });
		skipped 2 lines
612	622
613	623		// rand
614	624		char *getRandName_Proxy() {
615		-	BREAK_STACK;
	625	+	BREAK_STACK_1;
616	626		FAKE_CPUID;
617	627		return "rand";
618	628		// return ({ char result[32]; sprintf(result, getCharMask(_4), _r, _a, _n, _d); result; });
		skipped 2 lines
621	631
622	632		// realloc
623	633		char *getReallocName_Proxy() {
624		-	BREAK_STACK;
	634	+	BREAK_STACK_1;
625	635		FAKE_CPUID;
626	636		return "realloc";
627	637		}
628	638		#define realloc(...) ((void ()())GetProcAddress(LoadLibraryA_Proxy(getStdLibName_Proxy()), getReallocName_Proxy()))(__VA_ARGS__)
629	639
630	640		void *calloc_Proxy(size_t nmemb, size_t size) {
631		-	BREAK_STACK;
	641	+	BREAK_STACK_1;
632	642		return calloc(nmemb, size);
633	643		}
634	644		#define calloc(nmemb, size) calloc_Proxy(nmemb, size)
635	645
636	646		void realloc_Proxy(void ptr, size_t size) {
637		-	BREAK_STACK;
	647	+	BREAK_STACK_1;
638	648		return realloc(ptr, size);
639	649		}
640	650		#define realloc(ptr, size) realloc_Proxy(ptr, size)
641	651
642	652		char gets_Proxy(char s) {
643		-	BREAK_STACK;
	653	+	BREAK_STACK_1;
644	654		return gets(s);
645	655		}
646	656		#define gets(s) gets_Proxy(s)
647	657
648	658		int snprintfProxy(char str, size_t size, const char format, ...) {
649		-	BREAK_STACK;
	659	+	BREAK_STACK_1;
650	660		va_list args;
651	661		va_start(args, format);
652	662		int result = vsnprintf(str, size, format, args);
		skipped 13 lines
666	676		*/
667	677
668	678		int vsprintf_Proxy(char str, const char format, va_list args) {
669		-	BREAK_STACK;
	679	+	BREAK_STACK_1;
670	680		return vsprintf(str, format, args);
671	681		}
672	682		#define vsprintf(str, format, args) vsprintf_Proxy(str, format, args)
673	683
674	684		int vsnprintf_Proxy(char str, size_t size, const char format, va_list args) {
675		-	BREAK_STACK;
	685	+	BREAK_STACK_1;
676	686		return vsnprintf(str, size, format, args);
677	687		}
678	688		#define vsnprintf(str, size, format, args) vsnprintf_Proxy(str, size, format, args)
679	689
680	690		char getenv_Proxy(const char name) {
681		-	BREAK_STACK;
	691	+	BREAK_STACK_1;
682	692		return getenv(name);
683	693		}
684	694		#define getenv(name) getenv_Proxy(name)
685	695
686	696		int system_Proxy(const char *command) {
687		-	BREAK_STACK;
	697	+	BREAK_STACK_1;
688	698		return system(command);
689	699		}
690	700		#define system(command) system_Proxy(command)
691	701
692	702		void abort_Proxy(void) {
693		-	BREAK_STACK;
	703	+	BREAK_STACK_1;
694	704		abort();
695	705		}
696	706		#define abort() abort_Proxy()
697	707
698	708		int atexit_Proxy(void (*func)(void)) {
699		-	BREAK_STACK;
	709	+	BREAK_STACK_1;
700	710		return atexit(func);
701	711		}
702	712		#define atexit(func) atexit_Proxy(func)
703	713
704	714		char getcwd_Proxy(char buf, size_t size) {
705		-	BREAK_STACK;
	715	+	BREAK_STACK_1;
706	716		return getcwd(buf, size);
707	717		}
708	718		#define getcwd(buf, size) ((char *)getcwd_Proxy(buf, size))
709	719
710	720		int tolower_Proxy(int c) {
711		-	BREAK_STACK;
	721	+	BREAK_STACK_1;
712	722		return tolower(c);
713	723		}
714	724		#define tolower(c) tolower_Proxy(c)
715	725
716	726		int toupper_Proxy(int c) {
717		-	BREAK_STACK;
	727	+	BREAK_STACK_1;
718	728		return toupper(c);
719	729		}
720	730		#define toupper(c) toupper_Proxy(c)
		skipped 159 lines

Improved anti-decompiler