Buenas antes que nada, queria aclarar que estoy con ganas de 'escribir' algunos papers enfocados a exploiting desde un entorno Linux, da igual para Windows a excepción de algunas herramientas obviamente.
Estoy aca hace años asi que queria compartir esto con ustedes, ya que hay gente bastante experimentada.. me gustaria ver su punto de vista..
Son 3 posteos en 1 solo, ya que fui sacando por partes, es una introduccion a gdb desde linux.. una base para ir escalando y meternos en el exploiting..
#How to Exploit.Estos papers que pienso escribir iran enfocados para aquellos que tengan curiosidad sobre como explotar vulnerabilidades, descubrirlas, realizar ingeniería inversa, etc etc..
Me enfocare desde mi entorno Linux, pero es viable para Windows también, salvo excepciones de algunas herramientas, la esencia es la misma.
¿Requisitos?.Simplemente tener conocimientos basicos de programación.. compiladores, arquitectura, todo lo que nos rodea y usamos habitualmente, y en otros casos lo usamos pero no tenemos idea que lo hacemos.. Un requisito mas podria ser el saber y querer entender 'el porque de las cosas', no tirar un exploit a lo scriptkiddie. De todas maneras intentare enfocarme y detallar lo maximo que pueda. Para el resto, Google. Usare muchas herramientas como GDB, Objdump, IDA, GCC, Python,etc, etc..
#Primero, lo aburrido, pero necesario para entender.Vamos a familiarizarnos un poco con el código fuente, compilar, desensamblar, algunas herramientas que ayudan este proceso y todas esas cosas.
Para empezar tenemos preparado para esta prueba un pequeño codigo fuente "analizaMe",
esta codeado en C, y es de lo mas básico, pero me ayudara a explicarlo de manera rápida.. asi que deberíamos compilarlo. ¿Compilar?.
Suponiendo que si llegan hasta acá, siguieron al pie los requisitos de tener conocimientos basicos de programación, assembler, etc.. no sera muy difícil entender lo que refresco por encima a continuacion. Para comprender realmente el significado de Compilar, tenemos que movernos al origen de los procesadores, pero resaltaremos lo importante, el procesador x86.
Intel desarrollo la cpu 8086 que fue el primer procesador x86.. luego creo otros mas avanzados como el 386, 486.. etc.. El procesador x86 que se refiere a los anteriormente mencionados, posee varios registros que son como las 'variables' internas para dicho procesador. Algunos de estos registros son los conocidos 'EAX,ECX,EDX,EBX', son registros usados para varios fines, entre ellos como contadores o acumuladores.. sirven como variables temporales para el procesador cuando esta ejecutando instrucciones. Hay 4 registros mas a resaltar que son 'EBP, ESP, ESI y EDI'.
Estos registros llevan el nombre de EBP puntero base, ESP puntero de pila, ESI indice de origen y EDI indice destino. El puntero EIP, es el puntero de instruccion, es quien nos ayuda y nos señala a la instruccion que el procesador esta leyendo en ese preciso momento.
Bueno, como sabrán con el código fuente no vamos a poder hacer nada, hasta el momento en el que lo compilamos y lo convertimos en un archivo ejecutable.
Let's Go!
El programa analizaMe:
#include <stdio.h>
int main() {
int contar;
for(contar=0; contar < 5; contar++)
{
printf("La variable contar vale: %i \n", contar
); }
}
Bien, lo primero sera explicar un poco este código, y luego compilarlo.
Básicamente y de manera rápida, este programa lo que hace es mostrar en pantalla un mensaje y el valor de la variable 'contar'. Mientras sea la variable menor de 5 el mensaje sera mostrado via la funcion 'printf'. Cuando llega a 5, el programa finaliza. Analicémoslo mas en detalle..
(cada vez que vean $> es la manera de decirles que son comandos a tipear en la shell)
Vamos a compilarlo con GCC (es el GNU Compiler Collection), la función de los compiladores basicamente es la de convertir el código fuente en lenguaje maquina, la manera en la que entienden los procesadores.
$> gcc analizaMe.c -o analizaMe
$> chmod +x
$> ./analizaMeInvocamos al compilador y le decimos que nos compile el codigo fuente en c. El resultado es un nuevo archivo llamado analizaMe. Le damos permisos de ejecución. Y luego lo ejecutamos..
El resultado es el siguiente:
La variable contar vale: 0
La variable contar vale: 1
La variable contar vale: 2
La variable contar vale: 3
La variable contar vale: 4
Ok, vemos el resultado del programa, pero veamos que es lo que no esta a simple vista, como es que funciona este programa realmente..
Invocamos en la shell, a ojbdump, es una gran utilidad para desensamblar facilmente binarios compilados.
$> objdump -D analizaMe -M intel |grep -A15 main.:(Le decimos a objdump que (-D) desensamble el binario 'analizaMe', (-M intel) que nos muestre el resultado con la sintaxis Intel ya que es mas prolija y acostumbrado que la de AT&T (por default objdump nos arroja esta ultima por eso es que forzamos a que nos muestre con la de Intel)).. (grep -A15 main.
invocamos a 'grep' y aplicamos una expresión regular para que nos muestre solo las primeras 15 lineas de la funciona principal, main.
Podríamos no limitar a 15, pero arrojaría muchas lineas innecesaria para este momento.
Y hasta acá esta primera parte de introducción..
http://insecuritynotes.blogspot.com.ar/---------------------------------------------------------------------------------------------------------------------
#How to exploit 2: Un poco de Assembler y GNU Debugger.
Traje esta segunda parte que escribí, nose si tienen sugerencias positivas o negativas, cualquiera me serviría. Saludos.
Retomando con el paper anterior, y nuestro código de ejemplo, vamos a repasar un poco sobre Assembler y GNU Debugger durante esta segunda parte. Veremos por 'encima' el tema de assembler ya que mi interés no es un tutorial de este, sino repasarlo para introducirlo con el Debugger.
Para invocar al GDB
Utilizaremos el crudo y puro gdb desde la linea de comandos con sintaxis INTEL.
Para configurar GDB con sintaxis INTEL, vamos a hacer lo siguiente:
$> sudo gedit /etc/gdb/gdbint
Y luego pegamos al final la siguiente linea y guardamos el archivo:
set disassembly-flavor intel
La sintaxis de intel nos mostrara las operaciones de esta manera en gdb:
instrucciones "[destino],[origen]"
Por ejemplo: "mov ebx, eax"
En este ejemplo el valor del registro 'eax', sera movido al registro 'ebx'.
Recordar que las operaciones del origen y destino pueden ser un valor,
una dirección de memoria, o un registro como en este caso.
Operaciones comunes que veremos en assembler para refrescar memoria:
MOV: Mueve contenido
INC: Incrementa de a 1 el valor
DEC: Resta de a 1 el valor
ADD: Suma
SUB: Resta
CMP: Compara dos registros o un registro y dirección de memoria.
JMP/JNE etc: Todos los que empiecen con J.. son saltos condicionales e incondicionales.
Hay mas pero como dije, son los básicos y el paper no esta orientado a un manual de assembler.
# GDBEl debugger es una herramienta que nos permite ejecutar programas y analizarlos. Ya sea para localizar errores o entender un poco mas a fondo que es lo que hace una determinada aplicación.
GDB dispone de un comando muy particular y uno de los mas útiles a la hora de verificar la memoria.
Este comando se llama 'examine' y como su nombre indica, nos sirve para examinar la memoria.
GDB puede examinar detenidamente cada aspecto de la ejecución de un programa, ejecutarlo, detenerlo, verificar los registros, direcciones de memoria, lo que se nos ocurra.
(Lo practico de GDB también es que la mayoría de los comandos se pueden 'abreviar', por ejemplo examine se puede acortar a una simple 'x' y este se reconoce como un comando)
El comando examine, tiene varias maneras de arrojar la información que requerimos ver en una determinada dirección de memoria. Podemos especificar el formato en el que se muestra usando alguna de las siguiente abreviaturas:
x = Muestra el resultado en Hexadecimal
u = Muestra el resultado en Decimal.
o = Muestra el resultado en Octal.
t = Muestra el resultado en Binario.
Veamos un ejemplo con nuestro pequeño programa del paper anterior que adjunto nuevamente:
#include <stdio.h>
int main() {
int contar;
for(contar=0; contar < 5; contar++)
{
printf("La variable contar vale: %i \n", contar
); }
}
$> gdb -q ./analizaMe
De esta manera le pasamos a gdb el binario a debugguear.
(gdb) break main
Punto de interrupción 1 at 0x804840f (en mi caso esto nos responde gdb al poner un break)
Le decimos que genere un breakpoint en la función principal "main". Un breakpoint no hace otra cosa que poner una barrera una vez que se ejecuta el programa, le dice al gdb que cuando llegue a nuestro breakpoint el programa se parara obligatoriamente ahi en ese break. Podemos poner varios break, de momento solo haremos uno en la función main.
(gdb) run
Breakpoint 1, 0x0804840f in main () (esto nos responde el gdb al encontrar el break que seteamos)
Corremos el programa desde el debugger con run o también con una simple 'r' y va a parar en el primer breakpoint que seteamos en la función "main"
(gdb) info register
eax 0x1 1
ecx 0xbffff344 -1073745084
edx 0xbffff2d4 -1073745196
ebx 0xb7fc1000 -1208217600
esp 0xbffff2a8 0xbffff2a8
ebp 0xbffff2a8 0xbffff2a8
esi 0x0 0
edi 0x0 0
eip 0x804840f 0x804840f <main+3>
eflags 0x246 [ PF ZF IF ]
cs 0x73 115
ss 0x7b 123
ds 0x7b 123
es 0x7b 123
fs 0x0 0
gs 0x33 51
Este comando "info register" nos permite ver el estado actual de los registros.
Como ven obtenemos un status de todos los registros de ese preciso momento.
(gdb) info register eip
eip 0x804840f 0x804840f <main+3> (respuesta del gdb)
Podemos filtrar a algún registro en particular escribiéndolo al lado como en el ejemplo 'eip'.
Además, como les conté antes podemos 'abreviar' este comando asi: "i r eip"
Vemos como EIP contiene el valor 0x804840f.
(gdb) x/x $eip
0x804840f <main+3>: 0x83f0e483 (ahora examinamos la memoria a la que esta señalando el registro EIP usando la dirección almacenada en EIP). Vemos que donde arriba EIP contenia '0x804840f', examinamos este registro y contiene lo siguiente: 0x83f0e483.
De esa manera usamos el 'examine' abreviado con la primer 'x', luego le decimos que nos arroje la info en hexadecimal con la segunda 'x'. Y el registro 'eip'. Fíjense que en este caso hay que poner el registro luego de un $. A diferencia de el info register que no lo anteponíamos.
También se puede anteponer un numero al formato del comando examine, para examinar varias unidades en esas direcciones objetivos que tengamos. Por ejemplo:
(gdb) x/4x $eip
0x804840f <main+3>: 0x83f0e483 0x44c720ec 0x00001c24 0x19eb0000
Las unidades tienen un tamaño predeterminado de 4 bytes. Conocidas como WORD.
De la misma manera que podemos cambiar el formato que nos arroja el resultado con 'examine' ya sea en hexadecimal, octal, binario o decimal, tambien podemos cambiar el tamaño de las unidades que estamos examinando, agregandole una letra de tamaño al final de la de formato y estos son:
b: byte
h: half-word (2 bytes)
w: word (4 bytes)
g: giant o qword (8 bytes)
Veamos un ejemplo practico:
1)(gdb) x/4xb $eip
0x804840f <main+3>: 0x83 0xe4 0xf0 0x83
2)(gdb) x/4xh $eip
0x804840f <main+3>: 0xe483 0x83f0 0x20ec 0x44c7
3) (gdb) x/4xw $eip
0x804840f <main+3>: 0x83f0e483 0x44c720ec 0x00001c24 0x19eb0000
4) (gdb) x/4xg $eip
0x804840f <main+3>: 0x44c720ec83f0e483 0x19eb000000001c24
0x804841f <main+19>: 0x042444891c24448b 0xe8080484e82404c7
1- Como vemos en el ejemplo uno, le decimos a gdb que nos examine el registro $eip, y nos arroje en 4 unidades, en hexadecimal, y en tamaño byte.
2- En el segundo de la misma manera pero ya con 2 bytes.
3- Igual pero con 4 bytes.
4- Por ultimo igual, pero con 8 bytes.
#Resumen de este paper:
Ya sabemos, compilar un código fuente, gcc analizaMe.c.
Sabemos invocar el gdb y pasarle un binario para debuggearlo: gdb -q ./analizaMe
Sabemos que para poner un breakpoint y que se detenga el programa invocamos el comando 'break' + nombre de la función, o dirección en memoria donde queremos que pare.
Sabemos que una vez que para en el breakpoint, podemos verificar el status de los registros mediante 'info register' o alguno en particular como en nuestro caso anterior 'info register eip'.
Sabemos que la herramienta 'examine' nos permite verificar todas la memoria, direcciones y valores que se nos ocurra y arrojar el resultado de la manera que mas cómoda nos parezca, como en el ejemplo de 'x/x $eip' para ver el valor que contiene el registro EIP en ese momento y que nos arroje el resultado en hexadecimal.
Sabemos como mostrar por unidades como "x/2x"
Sabemos como mostrar examine en tamaño de unidades b,h,w,g (byte, 2bytes,4bytes, 8bytes).[/left][/li]
De momento dejamos acá esta segunda parte, y ya pronto escribo la tercera.
c0nfused.
---------------------------------------------------------------------------------------------------------------------
Vamos a retomar con este tercer paper, y analizar lo que hace nuestro humilde programa codeado en C.
Antes que nada, vamos a eliminar nuestro analizaMe compilado anteriormente, y vamos a volverlo a compilar con un parámetro nuevo que es la option flag "-g".
Genera mayor información de debug para ser utilizada por GDB.
Let's work!.
$> gcc -g analizaMe.c -o analizaMe (compilas con option flag -g)
$> chmod +x analizaMe (le damos permisos de ejecucion)
$> ./analizaMe (ejecutamos el binario para testear que todo haya salido correcto y recordar que hacia)
La variable contar vale: 0
La variable contar vale: 1
La variable contar vale: 2
La variable contar vale: 3
La variable contar vale: 4
Ok, todo funciono bien por fuera, analicemos que hace por dentro, con lo aprendido anteriormente en GDB.
ACLARACIÓN: Puede que las direcciones de memoria de SUS PCS respecto a las mías en estos ejemplos NO SEAN IGUALES. Y seria algo lógico..
Asi que no se preocupen, que podrán seguir igual los ejemplos...
$> gdb -q ./analizaMe (abrimos el binario creado con nuestro debugger favorito
)
(gdb) b main (breakpoint en la funcion principal main)
Punto de interrupción 1 at 0x8048415: file analizaMe.c, line 4. (respuesta del gdb).
(gdb) r (corremos el programa con el comando run o r abreviado)
Breakpoint 1, main () at analizaMe.c:4
4 for(contar=0; contar < 5; contar++)
Bien como vemos, para en el punto de interrupción que nosotros mismos pusimos en main.
Y como vemos nos adjunta '+ información' gracias al option flag -g que agregamos.
Bien, vamos a verificar como esta el panorama..
(gdb) i r $eipeip 0x8048415 0x8048415 <main+9>
(verificamos la información del registro $eip y vemos que apunta a esa direccion).
(gdb) x/3i $eip=> 0x8048415 <main+9>: mov DWORD PTR [esp+0x1c],0x0
0x804841d <main+17>: jmp 0x8048438 <main+44>
0x804841f <main+19>: mov eax,DWORD PTR [esp+0x1c]
Como anteriormente vimos, la opción 'i' era la de instrucción. Le decimos a GDB que nos muestre solo las próximas 3 instrucciones a ejecutarse para guiarnos de que esta haciendo el programa y que va a hacer.
Si hicieron la tarea y refrescaron un poco assembler, fundamental para explotar cualquier vulnerabilidad... recordamos también cuando explique algunas instrucciones de assembler, como por ejemplo 'mov'.
A simple vista entonces, GDB nos dice que donde ahora mismo esta parado, va a realizar una operación en la cual 'moverá' el valor de la derecha '0x0' hacia la izquierda en donde tenemos como destino una dirección en memoria (esp+0x1c). Nota: Es muy común ver este tipo de direcciones, porque si recordamos sabemos que EAX, EBX, EDI, ESI, ESP, etc son registros y es común leer ESP+4 o EBP-4 y cosas asi, este caso nos dice que lo va a mover a ESP+0x1c. 0x1c en decimal equivale a 28. Por lo que seria $esp+28.
Si recordamos también que el programa paro en nuestro breakpoint en main justo cuando comenzaba el for y nos arrojo esta información:
"4 for(contar=0; contar < 5; contar++)"
Podríamos deducir que ese valor 0x0 que va a mover, es el que le dimos en el FOR a nuestra variable llamada 'contar'.
Analicemos esa dirección de memoria que valor contiene en este momento con el programa pausado en nuestro breakpoint:
(gdb) i r $espesp 0xbffff270 (En el registro ESP encontramos una dirección de memoria 0xbffff270)
Por lo tanto BFFFF270 + 1C (ESP+28) = BFFFF28C. (tranquilos, todo eso el debugger lo obvia por nosotros y lo sabe, pero para que entendamos, otra aclaración for dummys, siempre que veamos 0x12345678 esa '0x' del principio nos indica que es una notación Hexadecimal, la dirección seria 12345678.)
Bien, volviendo a la practica verificamos con GDB, la siguiente linea:
=> 0x8048415 <main+9>: mov DWORD PTR [esp+0x1c],0x0
(gdb) x/x $esp+0x1c0xbffff28c: 0xb7fc1000
Como vemos nos responde lo que anteriormente les aclare, esp contiene una dirección y esa dirección + 28 (1c) es BFFFF28c, y GDB nos dice que esa dirección contiene el siguiente valor: 0xb7fc1000.
Por lo tanto lo que pasaría ahora es que al ejecutar la siguiente instrucción:
"mov DWORD PTR [esp+0x1c],0x0" ..ese valor dejaria de existir y pasaria a ser 0x0 con la operacion de mov.
Voy a comentarles un nuevo comando el cual nos permite por asi decirlo, crear temporalmente un 'acceso directo' a una determinada direccion, para no tener que escribirla constantemente y verificar si tiene cambios en su contenido:
(gdb) print $esp+0x1c$1 = (void *) 0xbffff28c
(Le decimos a gdb que nos cree una variable temporal de la dirección de memoria $esp+0x1c, para accederla fácilmente cuando queramos, y gdb nos responde diciendo que se creo la variable $1)
Ahora usaremos el comando 'nexti' para ejecutar la siguiente instrucción, nexti hace que el programa vaya paso a paso, instruccion por instruccion, luego del breakpoint que pusimos.
(gdb) nexti0x0804841d 4 for(contar=0; contar < 5; contar++)
Ejecutamos nexti. Veamos si la dirección $esp+0x1c (0xbffff28c) 0xb7fc1000 que contenía valores aleatorios.. ha cambiado.
(gdb) x/x $1 0xbffff28c: 0x00000000
Efectivamente, se cumplió la operación 'mov' y movió el valor '0x0' a la dirección de esp+0x1c.
Veamos donde esta parado ahora el registro EIP y cuales son sus siguientes operaciones:
(gdb) x/10i $eip (le decimos a gdb que nos arroje las proximas 10 instrucciones).
Como vemos en la imagen, EIP apunta a una instrucción en donde hay un JMP (JUMP), un salto el cual tiene como destino la dirección 0x8048438. Que es la 7ma linea de las 10 que pedimos que nos muestre. Le damos a nexti.
(gdb) nexti0x08048438 4 for(contar=0; contar < 5; contar++)
Vemos que seguimos en el FOR.
(gdb) x/3i $eip
=> 0x8048438 <main+44>: cmp DWORD PTR [esp+0x1c],0x4
0x804843d <main+49>: jle 0x804841f <main+19>
0x804843f <main+51>: leave
Ok, confirmamos que salto a la dirección 8048438 como sabíamos.
Y ahora lo que va a hacer es a comparar mediante la instrucción 'cmp'. El valor 0x4 (4) contra el valor que esta guardado en la dirección [esp+0x1c] (nuestra famosa dirección que podemos acceder temporalmente mediante la variable $1 que seteamos anteriormente).
Como sabemos por la ultima vez que vimos la dirección esa contenía el valor '0'. Por lo tanto comparara el valor 4, contra el valor 0. Exactamente en esta parte del FOR estamos: "contar < 5"
Le damos a nexti...
(gdb) nexti0x0804843d 4 for(contar=0; contar < 5; contar++)
(gdb) x/i $eip=> 0x804843d <main+49>: jle 0x804841f <main+19>
Luego de ejecutar 'nexti' nos lleva a la siguiente instrucción, y si la verificamos con examine para ver donde esta parado EIP, nos encontramos con un JLE. Como recordamos, J.. es sinónimo de JUMP, pero en este caso es un salto 'condicional' que significa JUMP LESS EQUAL. Y quiere decir que SALTA, SI ES MENOR o IGUAL.....
Como evidentemente esto es cierto, ya que 0 es menor que 4.. entonces salta a la dirección 0x804841f.
(gdb) x/i $eip=> 0x804841f <main+19>: mov eax,DWORD PTR [esp+0x1c]
Estábamos en lo correcto, y salto nomas a la dirección previamente dicha.
Si verificamos las siguientes 10 instrucciones:
Observamos que en la 4ta linea de las 10 solicitadas, hay un "CALL 0x80482F0".
Que es el encargado de llamar a la función PRINTF. (La que imprime en pantalla el primer mensaje de "La variable contar vale: 0" que observamos al ejecutar el programa).
Para que se entienda, cuando llegamos a una instrucción donde hay un CALL como en este caso el programa se desvia a una subrutina, es como si fuese una porción de código aparte en la cual se realizan otras operaciones y una vez que se concluyen al final de ese código de la subrutina hay una instrucción llamada RET (de return/regreso).
Vean la siguiente imagen.. (sacada de Google Imágenes).
Por lo tanto, luego de la llamada a esa función, el RET debería dejarnos justituto en la siguiente dirección 0x8048433:
Ok, siguiendo con nuestro análisis, ya estamos por el final, espero no se hayan perdido.
(gdb) x/5i $eip=> 0x8048433 <main+39>: add DWORD PTR [esp+0x1c],0x1
0x8048438 <main+44>: cmp DWORD PTR [esp+0x1c],0x4
0x804843d <main+49>: jle 0x804841f <main+19>
0x804843f <main+51>: leave
0x8048440 <main+52>: ret
EIP apunta a una instrucción conocida llamada 'add' la cual sirve para 'sumar' dos operandos y lo guarda en el lugar destino, en este caso 0x1 en nuestra conocida dirección de memoria
.
Le damos a 'nexti'.. y luego verificamos después de esta operación si el valor de esa dirección de memoria tuvo algún cambio..
(gdb) nexti0x08048438 4 for(contar=0; contar < 5; contar++)
(gdb) x/x $10xbffff28c: 0x00000001
Efectivamente.. ahora contiene el valor de 1.
Si miramos un poco mas las siguientes dos instrucciones:
(gdb) x/2i $eip=> 0x8048438 <main+44>: cmp DWORD PTR [esp+0x1c],0x4
0x804843d <main+49>: jle 0x804841f <main+19>
Ya nos resulta conocida, y es que esta nuevamente comparando el valor de 4 con el ahora 1.
Luego viene el ya explicado JLE - va a saltar si es menor o igual que 4.
Como lo és, salta a 0x804841f. Y así seguiría el loop.. hasta que si seguimos analizando el programa paso a paso con nexti y verificando el valor de la dirección en $1.. llegaríamos a:
(gdb) x/x $10xbffff28c: 0x00000005
(gdb) x/i $eip=> 0x8048438 <main+44>: cmp DWORD PTR [esp+0x1c],0x4
(gdb) x/5i $eip=> 0x8048438 <main+44>: cmp DWORD PTR [esp+0x1c],0x4
0x804843d <main+49>: jle 0x804841f <main+19>
0x804843f <main+51>: leave
0x8048440 <main+52>: ret
Luego de ir sumándole 1 por cada loop de imprimir en pantalla, nuestra famosa dirección contiene el valor de 5.
Por lo tanto al siguiente 'cmp', de comparar si 5 es menor o igual que 4? y matemáticamente es negativo, NO se cumpliría el JLE condicional por lo que las siguiente dos instrucciones serian:
(gdb) x/2i $eip=> 0x804843f <main+51>: leave
0x8048440 <main+52>: ret
0xb7e344d3 <__libc_start_main+243>: mov DWORD PTR [esp],eax
0xb7e344d6 <__libc_start_main+246>: call 0xb7e4dfb0 <exit>
(gdb) nexti
[Inferior 1 (process 5324) exited with code 034]
De esta manera finaliza el tercer paper.. y uno de los mas largos.
Gracias
.
#c0nfused -
allmenage@gmail.com -
http://insecuritynotes.blogspot.com
Mostrar Temas
![](http://[https://1.bp.blogspot.com/-bgLKKknt7lY/Wfv8YRRMHQI/AAAAAAAAA60/KV5WEnEslHUofT8Sml-mkCuBvJafWdcQgCEwYBhgL/s1600/etc_passwd.jpg/img]k, podemos ver que existen 3 usuarios en el sistema ademas de root.. un tal RickSanchez, Morty y Summer.Luego de seguir investigando en los archivos locales, relacionados al site, en el path: /var/www/html/passwords/passwords.htmlme encuentro con un dato interesante:"Wow Morty real clever. Storing passwords in a file called passwords.html? You've really done it this time Morty. Let me at least hide them.. I'd delete them entirely but I know you'd go bitching to your mom. That's the last thing I need."Parece ser que hay un password oculto.. y al ver que el archivo es .html, mejor verlo con curl.[img]https://3.bp.blogspot.com/--j-07MUINCk/Wfv8Zu-H0mI/AAAAAAAAA60/Zi75CgNTW7wBjJ0_NS5p7vTrKJxLMn75gCEwYBhgL/s1600/password_curl.jpg)
