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

Ideas para la programacion de w0rm's o malware en general

  • 4 Respuestas
  • 2177 Vistas

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

Desconectado ksha

  • *
  • Underc0der
  • Mensajes: 46
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« en: Marzo 01, 2011, 02:14:37 pm »
Hola, como en un post anterior (You are not allowed to view links. Register or Login) mio parece que no se entendio el concepto les dejo un mini howto poc xD, a ver si les sirve para algo aun que sea para investigar mas. como no entrare en detalle por falta de tiempo ademas estoy escribiendo en el trabajo.

Ofuscacion: La ofuscación se refiere a encubrir el significado de una comunicación haciéndola más confusa y complicada de interpretar. You are not allowed to view links. Register or Login

Criptografia: La criptografía (del griego κρύπτω krypto, «oculto», y γράφω graphos, «escribir», literalmente «escritura oculta») es la técnica, bien sea aplicada al arte o la ciencia, que altera las representaciones lingüísticas de un mensaje. You are not allowed to view links. Register or Login

Para comprender completamente este documento deberan leer sobre asm basico, syscall's y manejar C a bajo nivel tanto asi como estructuras, manejo de memoria dinamica y punteros.

basta de charla y vamos a la accion.

tenemos el siguiente codigo fuente el cual imprime un texto.

normal.c
Código: C
  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.         You are not allowed to view links. Register or Login("Codigo Normal\n");
  6.         return 0;
  7. }
  8.  

Lo compilaremos sin optimizacion + gdb

Código: You are not allowed to view links. Register or Login
ksha@warbof:~/dev/c/ofus$ gcc -ggdb -O0 -o normal normal.c
ksha@warbof:~/dev/c/ofus$ ./normal
Codigo Normal
ksha@warbof:~/dev/c/ofus$

codigo disas
Código: You are not allowed to view links. Register or Login
080483c4 <main>:
#include <stdio.h>

int main()
{
 80483c4: 55                    push   %ebp
 80483c5: 89 e5                mov    %esp,%ebp
 80483c7: 83 e4 f0              and    $0xfffffff0,%esp
 80483ca: 83 ec 10              sub    $0x10,%esp
printf("Codigo Normal\n");
 80483cd: c7 04 24 a0 84 04 08 movl   $0x80484a0,(%esp)
 80483d4: e8 1f ff ff ff        call   80482f8 <puts@plt>
return 0;
 80483d9: b8 00 00 00 00        mov    $0x0,%eax
}
 80483de: c9                    leave 
 80483df: c3                    ret   

si analizamos el binario simplemente nos mostraria la informacion del printf o cadena depende del caso y que uso se le de.
Código: You are not allowed to view links. Register or Login
ksha@warbof:~/dev/c/ofus$ strings normal
/lib/ld-linux.so.2
__gmon_start__
libc.so.6
_IO_stdin_used
puts
__libc_start_main
GLIBC_2.0
PTRh
[^_]
Codigo Normal
ksha@warbof:~/dev/c/ofus$

si por ejemplo ponen cadenas con los procesos Av mas comunes seran detectados rapidamente.

veamos el primer ejemplo de ofuscacion.

NOTA: debes saber C avanzado para enterder algunas lineas del codigo.

ofus1.c
Código: C
  1. extern int You are not allowed to view links. Register or Login(__const char *__restrict __format, ...);
  2.  
  3. int main()
  4. {
  5.         You are not allowed to view links. Register or Login("Codigo Normal\n");
  6.         return 0;
  7. }
  8.  

Código: You are not allowed to view links. Register or Login
ksha@warbof:~/dev/c/ofus$ gcc -ggdb -O0 -o ofus1 ofus1.c   
ksha@warbof:~/dev/c/ofus$ ./ofus1
Codigo Normal

revizando las cadenas ...

Código: You are not allowed to view links. Register or Login
ksha@warbof:~/dev/c/ofus$ strings ofus1
/lib/ld-linux.so.2
__gmon_start__
libc.so.6
_IO_stdin_used
puts
__libc_start_main
GLIBC_2.0
PTRh
[^_]
Codigo Normal
ksha@warbof:~/dev/c/ofus$

disasm
Código: You are not allowed to view links. Register or Login
080483c4 <main>:

int main()
{
 80483c4: 55                    push   %ebp
 80483c5: 89 e5                mov    %esp,%ebp
 80483c7: 83 e4 f0              and    $0xfffffff0,%esp
 80483ca: 83 ec 10              sub    $0x10,%esp
printf("Codigo Normal\n");
 80483cd: c7 04 24 a0 84 04 08 movl   $0x80484a0,(%esp)
 80483d4: e8 1f ff ff ff        call   80482f8 <puts@plt>
return 0;
 80483d9: b8 00 00 00 00        mov    $0x0,%eax
}
 80483de: c9                    leave 
 80483df: c3                    ret   

veamos con el src normal que tal va

normal.c
Código: C
  1. #include <stdio.h>
  2.  
  3. char *decrypt( char *str)
  4. {
  5.         char *pos = str ;
  6.  
  7.         while( *pos != 0)
  8.         {
  9.                 *pos ^= ( char) 0x0FF ;
  10.                 pos++ ;
  11.         }
  12.        
  13.         return str ;
  14. }
  15.  
  16. char secret[]={
  17.                                 'C'             ^ ( char) 0x0FF,
  18.                                 'o'             ^ ( char) 0x0FF,
  19.                                 'd'             ^ ( char) 0x0FF,
  20.                                 'i'             ^ ( char) 0x0FF,
  21.                                 'g'             ^ ( char) 0x0FF,
  22.                                 'o'             ^ ( char) 0x0FF,
  23.                                 ' '             ^ ( char) 0x0FF,
  24.                                 'N'             ^ ( char) 0x0FF,
  25.                                 'o'             ^ ( char) 0x0FF,
  26.                                 'r'             ^ ( char) 0x0FF,
  27.                                 'm'             ^ ( char) 0x0FF,
  28.                                 'a'             ^ ( char) 0x0FF,
  29.                                 'l'             ^ ( char) 0x0FF,
  30.                                 0                                      
  31.                                 } ;
  32.  
  33. int main()
  34. {
  35.         You are not allowed to view links. Register or Login("%s\n",decrypt(secret));
  36.         return 0;
  37. }
  38.  

Código: You are not allowed to view links. Register or Login
ksha@warbof:~/dev/c/ofus$ gcc -ggdb -O0 -o normal2 normal2.c
ksha@warbof:~/dev/c/ofus$ ./normal2
Codigo Normal
ksha@warbof:~/dev/c/ofus$ strings normal2
/lib/ld-linux.so.2
__gmon_start__
libc.so.6
_IO_stdin_used
puts
__libc_start_main
GLIBC_2.0
PTRh
[^_]

aplicando el XOR 0x0FF cambia drasticamente ya q ahora no vemos cadenas.

Código: You are not allowed to view links. Register or Login
080483c4 <decrypt>:
#include <stdio.h>

char *decrypt( char *str)
{
 80483c4: 55                    push   %ebp
 80483c5: 89 e5                mov    %esp,%ebp
 80483c7: 83 ec 10              sub    $0x10,%esp
char *pos = str ;
 80483ca: 8b 45 08              mov    0x8(%ebp),%eax
 80483cd: 89 45 fc              mov    %eax,-0x4(%ebp)

while( *pos != 0)
 80483d0: eb 13                jmp    80483e5 <decrypt+0x21>
{
*pos ^= ( char) 0x0FF ;
 80483d2: 8b 45 fc              mov    -0x4(%ebp),%eax
 80483d5: 0f b6 00              movzbl (%eax),%eax
 80483d8: 89 c2                mov    %eax,%edx
 80483da: f7 d2                not    %edx
 80483dc: 8b 45 fc              mov    -0x4(%ebp),%eax
 80483df: 88 10                mov    %dl,(%eax)
pos++ ;
 80483e1: 83 45 fc 01          addl   $0x1,-0x4(%ebp)

char *decrypt( char *str)
{
char *pos = str ;

while( *pos != 0)
 80483e5: 8b 45 fc              mov    -0x4(%ebp),%eax
 80483e8: 0f b6 00              movzbl (%eax),%eax
 80483eb: 84 c0                test   %al,%al
 80483ed: 75 e3                jne    80483d2 <decrypt+0xe>
{
*pos ^= ( char) 0x0FF ;
pos++ ;
}

return str ;
 80483ef: 8b 45 08              mov    0x8(%ebp),%eax
}
 80483f2: c9                    leave 
 80483f3: c3                    ret   

080483f4 <main>:
'l' ^ ( char) 0x0FF,
0
} ;

int main()
{
 80483f4: 55                    push   %ebp
 80483f5: 89 e5                mov    %esp,%ebp
 80483f7: 83 e4 f0              and    $0xfffffff0,%esp
 80483fa: 83 ec 10              sub    $0x10,%esp
printf("%s\n",decrypt(secret));
 80483fd: c7 04 24 ec 95 04 08 movl   $0x80495ec,(%esp)
 8048404: e8 bb ff ff ff        call   80483c4 <decrypt>
 8048409: 89 04 24              mov    %eax,(%esp)
 804840c: e8 e7 fe ff ff        call   80482f8 <puts@plt>
return 0;
 8048411: b8 00 00 00 00        mov    $0x0,%eax
}
 8048416: c9                    leave 
 8048417: c3                    ret   
 8048418: 90                    nop
 8048419: 90                    nop
 804841a: 90                    nop
 804841b: 90                    nop
 804841c: 90                    nop
 804841d: 90                    nop
 804841e: 90                    nop
 804841f: 90                    nop

Código: You are not allowed to view links. Register or Login
ksha@warbof:~/dev/c/ofus$ gcc -ggdb -O0 -o ofus2 ofus2.c     
ksha@warbof:~/dev/c/ofus$ ./ofus2
Codigo Normal
ksha@warbof:~/dev/c/ofus$ strings ofus2
/lib/ld-linux.so.2
__gmon_start__
libc.so.6
_IO_stdin_used
puts
__libc_start_main
GLIBC_2.0
PTRh
[^_]

viendo el disasm

Código: You are not allowed to view links. Register or Login
080483c4 <decrypt>:
extern int printf(__const char *__restrict __format, ...);

char *decrypt( char *str)
{
 80483c4: 55                    push   %ebp
 80483c5: 89 e5                mov    %esp,%ebp
 80483c7: 83 ec 10              sub    $0x10,%esp
char *pos = str ;
 80483ca: 8b 45 08              mov    0x8(%ebp),%eax
 80483cd: 89 45 fc              mov    %eax,-0x4(%ebp)

while( *pos != 0)
 80483d0: eb 13                jmp    80483e5 <decrypt+0x21>
{
*pos ^= ( char) 0x0FF ;
 80483d2: 8b 45 fc              mov    -0x4(%ebp),%eax
 80483d5: 0f b6 00              movzbl (%eax),%eax
 80483d8: 89 c2                mov    %eax,%edx
 80483da: f7 d2                not    %edx
 80483dc: 8b 45 fc              mov    -0x4(%ebp),%eax
 80483df: 88 10                mov    %dl,(%eax)
pos++ ;
 80483e1: 83 45 fc 01          addl   $0x1,-0x4(%ebp)

char *decrypt( char *str)
{
char *pos = str ;

while( *pos != 0)
 80483e5: 8b 45 fc              mov    -0x4(%ebp),%eax
 80483e8: 0f b6 00              movzbl (%eax),%eax
 80483eb: 84 c0                test   %al,%al
 80483ed: 75 e3                jne    80483d2 <decrypt+0xe>
{
*pos ^= ( char) 0x0FF ;
pos++ ;
}

return str ;
 80483ef: 8b 45 08              mov    0x8(%ebp),%eax
}
 80483f2: c9                    leave 
 80483f3: c3                    ret   

080483f4 <main>:
'l' ^ ( char) 0x0FF,
0
} ;

int main()
{
 80483f4: 55                    push   %ebp
 80483f5: 89 e5                mov    %esp,%ebp
 80483f7: 83 e4 f0              and    $0xfffffff0,%esp
 80483fa: 83 ec 10              sub    $0x10,%esp
printf("%s\n",decrypt(secret));
 80483fd: c7 04 24 ec 95 04 08 movl   $0x80495ec,(%esp)
 8048404: e8 bb ff ff ff        call   80483c4 <decrypt>
 8048409: 89 04 24              mov    %eax,(%esp)
 804840c: e8 e7 fe ff ff        call   80482f8 <puts@plt>
return 0;
 8048411: b8 00 00 00 00        mov    $0x0,%eax
}
 8048416: c9                    leave 
 8048417: c3                    ret   
 8048418: 90                    nop
 8048419: 90                    nop
 804841a: 90                    nop
 804841b: 90                    nop
 804841c: 90                    nop
 804841d: 90                    nop
 804841e: 90                    nop
 804841f: 90                    nop

y les dejo el ultimo un poco mas optimizado.

Código: C
  1. #include <unistd.h>
  2.  
  3. char *decrypt( char *str)
  4. {
  5.         char *pos = str ;
  6.  
  7.         while( *pos != 0)
  8.         {
  9.                 *pos ^= ( char) 0x0FF ;
  10.                 pos++ ;
  11.         }
  12.        
  13.         return str ;
  14. }
  15.  
  16. char secret[]={
  17.                                 'C'             ^ ( char) 0x0FF,
  18.                                 'o'             ^ ( char) 0x0FF,
  19.                                 'd'             ^ ( char) 0x0FF,
  20.                                 'i'             ^ ( char) 0x0FF,
  21.                                 'g'             ^ ( char) 0x0FF,
  22.                                 'o'             ^ ( char) 0x0FF,
  23.                                 ' '             ^ ( char) 0x0FF,
  24.                                 'N'             ^ ( char) 0x0FF,
  25.                                 'o'             ^ ( char) 0x0FF,
  26.                                 'r'             ^ ( char) 0x0FF,
  27.                                 'm'             ^ ( char) 0x0FF,
  28.                                 'a'             ^ ( char) 0x0FF,
  29.                                 'l'             ^ ( char) 0x0FF,
  30.                                 '\n'            ^ ( char) 0x0FF,
  31.                                 0                                      
  32.                                 } ;
  33.  
  34. int main()
  35. {
  36.         decrypt(secret);
  37.         write(STDOUT_FILENO,&secret,sizeof(secret));
  38.         return 0;
  39. }
  40.  

Código: You are not allowed to view links. Register or Login
ksha@warbof:~/dev/c/ofus$ gcc -ggdb -O0 -o ofus3 ofus3.c
ksha@warbof:~/dev/c/ofus$ ./ofus3
Codigo Normal
ksha@warbof:~/dev/c/ofus$ strings ofus3
/lib/ld-linux.so.2
__gmon_start__
libc.so.6
_IO_stdin_used
__libc_start_main
write
GLIBC_2.0
PTRh0
[^_]

Código: You are not allowed to view links. Register or Login
080483c4 <decrypt>:
#include <unistd.h>

char *decrypt( char *str)
{
 80483c4: 55                    push   %ebp
 80483c5: 89 e5                mov    %esp,%ebp
 80483c7: 83 ec 10              sub    $0x10,%esp
char *pos = str ;
 80483ca: 8b 45 08              mov    0x8(%ebp),%eax
 80483cd: 89 45 fc              mov    %eax,-0x4(%ebp)

while( *pos != 0)
 80483d0: eb 13                jmp    80483e5 <decrypt+0x21>
{
*pos ^= ( char) 0x0FF ;
 80483d2: 8b 45 fc              mov    -0x4(%ebp),%eax
 80483d5: 0f b6 00              movzbl (%eax),%eax
 80483d8: 89 c2                mov    %eax,%edx
 80483da: f7 d2                not    %edx
 80483dc: 8b 45 fc              mov    -0x4(%ebp),%eax
 80483df: 88 10                mov    %dl,(%eax)
pos++ ;
 80483e1: 83 45 fc 01          addl   $0x1,-0x4(%ebp)

char *decrypt( char *str)
{
char *pos = str ;

while( *pos != 0)
 80483e5: 8b 45 fc              mov    -0x4(%ebp),%eax
 80483e8: 0f b6 00              movzbl (%eax),%eax
 80483eb: 84 c0                test   %al,%al
 80483ed: 75 e3                jne    80483d2 <decrypt+0xe>
{
*pos ^= ( char) 0x0FF ;
pos++ ;
}

return str ;
 80483ef: 8b 45 08              mov    0x8(%ebp),%eax
}
 80483f2: c9                    leave 
 80483f3: c3                    ret   

080483f4 <main>:
'\n' ^ ( char) 0x0FF,
0
} ;

int main()
{
 80483f4: 55                    push   %ebp
 80483f5: 89 e5                mov    %esp,%ebp
 80483f7: 83 e4 f0              and    $0xfffffff0,%esp
 80483fa: 83 ec 10              sub    $0x10,%esp
decrypt(secret);
 80483fd: c7 04 24 fc 95 04 08 movl   $0x80495fc,(%esp)
 8048404: e8 bb ff ff ff        call   80483c4 <decrypt>
write(STDOUT_FILENO,&secret,sizeof(secret));
 8048409: c7 44 24 08 0f 00 00 movl   $0xf,0x8(%esp)
 8048410: 00
 8048411: c7 44 24 04 fc 95 04 movl   $0x80495fc,0x4(%esp)
 8048418: 08
 8048419: c7 04 24 01 00 00 00 movl   $0x1,(%esp)
 8048420: e8 c7 fe ff ff        call   80482ec <write@plt>
return 0;
 8048425: b8 00 00 00 00        mov    $0x0,%eax
}
 804842a: c9                    leave 
 804842b: c3                    ret   
 804842c: 90                    nop
 804842d: 90                    nop
 804842e: 90                    nop
 804842f: 90                    nop

.. continua ..
« Última modificación: Febrero 08, 2014, 05:19:09 pm por Expermicid »
You are not allowed to view links. Register or Login

Desconectado ksha

  • *
  • Underc0der
  • Mensajes: 46
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #1 en: Marzo 01, 2011, 02:25:25 pm »
Debuggeando ?

No lo pondre ya que es demasiado largo y no quiero seguir poniendo mil post para terminar.

lo que si se los dejo como tarea.

You are not allowed to view links. Register or Login

Conclusion.

Es factible utilizar ofuscacion en la creacion de malware ?

totalmente, ojala siempre programen de forma ofuscada podria darles mas codigo pero eso va a depender de como preguntes aca las cosas. tampoco quiero darles todo en bandeja de plata.

Y la criptografia ?

Sep, osea mejor aun si quieren inventar un metodo de cifrado propio seria salvaje lo mas probable es que las compañias AV esten hasta cuando analizando, obviamente hay muchachos q superan el cerebro normal y si tu codigo no es lo suficientemente grotesco lo mas probable es que no se demoren mucho en romperlo (Piensen en PS3 como ejemplo).

para generar codigos mas robustos y dificiles de entender podrian agregar funciones voip o nops osea que no hagan nada asi al desamblar el binario final estaran como 10000 años tratando de ver que son esas funciones.



debugueen el normal1 y el ofuscado3 ... bueno y si tienen tiempo para debuggear el resto les serviria para apreciar mejor las diferencias entre uno y otro.
Espero que les guste, y que me den ideas para programar y generar algunos sources mejores en el tiempo.
Respondere solo preguntas y comentarios relacionados a los codigos.
Por favor no pongas las gracias ya que no las necesito y se rellena el thread con basura.

cualquier duda mas especifica la respondo por mail.
ksha@mitm.cl

« Última modificación: Marzo 01, 2011, 02:37:44 pm por ksha »
You are not allowed to view links. Register or Login

Desconectado Juan

  • *
  • Underc0der
  • Mensajes: 159
  • Actividad:
    0%
  • Reputación 0
  • Ex-Drinky
    • Ver Perfil
« Respuesta #2 en: Marzo 01, 2011, 02:36:49 pm »
Muy bueno el artículo, se nota que sabes programar  :P.
Quizas el simple xor sea detectado por F-PROT o similares y tendrán que idear otra encriptación.. jejeje. Ya vi que lo pusistes tu. jeje

salu2!
« Última modificación: Marzo 01, 2011, 02:39:48 pm por Drinky94 »

Desconectado ksha

  • *
  • Underc0der
  • Mensajes: 46
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #3 en: Marzo 01, 2011, 02:42:50 pm »
Habria q pasarles el source por linea de comandos a los av que hay ... jamas he utilizado un av paral inux :S, en algunos servidores que veo el clamav que es para los virus que hay en correo pero nada mas lo bajare y testiare a ver que tal anda.
You are not allowed to view links. Register or Login

Desconectado Ahkbar

  • *
  • Underc0der
  • Mensajes: 31
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
    • Email
« Respuesta #4 en: Abril 24, 2011, 11:24:11 pm »
le aplicai ksha, despùes la practico, cuando tenga el bicho qlo xD
You are not allowed to view links. Register or Login

 

¿Te gustó el post? COMPARTILO!



Ahorcado_game hecho en cosola, Basico para realizar proyectos

Iniciado por vasilick

Respuestas: 2
Vistas: 408
Último mensaje Febrero 07, 2018, 08:11:28 am
por Mr.Tru
AsciitoX - conversor de texto para tu terminal

Iniciado por andergedon

Respuestas: 0
Vistas: 1148
Último mensaje Marzo 19, 2018, 02:35:17 am
por andergedon
Estructuras, para quien las quiera xD

Iniciado por binary112

Respuestas: 0
Vistas: 275
Último mensaje Febrero 04, 2018, 07:03:35 pm
por binary112
Manual de compilacion C/C++ en GCC para GNU/Linux

Iniciado por Dharok

Respuestas: 1
Vistas: 1943
Último mensaje Enero 30, 2011, 01:13:58 am
por vertex@Symphony
Un poco sobre Qt y C++ para que se animen! :)

Iniciado por Turka

Respuestas: 4
Vistas: 6151
Último mensaje Noviembre 28, 2017, 03:52:23 pm
por rush