Deserialization
Last updated
Last updated
Aprende y practica Hacking en AWS:HackTricks Training AWS Red Team Expert (ARTE) Aprende y practica Hacking en GCP: HackTricks Training GCP Red Team Expert (GRTE)
La serialización se entiende como el método de convertir un objeto en un formato que puede ser preservado, con la intención de almacenar el objeto o transmitirlo como parte de un proceso de comunicación. Esta técnica se emplea comúnmente para asegurar que el objeto pueda ser recreado en un momento posterior, manteniendo su estructura y estado.
La deserialización, por el contrario, es el proceso que contrarresta la serialización. Implica tomar datos que han sido estructurados en un formato específico y reconstruirlos de nuevo en un objeto.
La deserialización puede ser peligrosa porque potencialmente permite a los atacantes manipular los datos serializados para ejecutar código dañino o causar un comportamiento inesperado en la aplicación durante el proceso de reconstrucción del objeto.
En PHP, se utilizan métodos mágicos específicos durante los procesos de serialización y deserialización:
__sleep
: Invocado cuando un objeto está siendo serializado. Este método debe devolver un array con los nombres de todas las propiedades del objeto que deben ser serializadas. Se utiliza comúnmente para comprometer datos pendientes o realizar tareas de limpieza similares.
__wakeup
: Llamado cuando un objeto está siendo deserializado. Se utiliza para restablecer cualquier conexión a la base de datos que pueda haberse perdido durante la serialización y realizar otras tareas de reinicialización.
__unserialize
: Este método se llama en lugar de __wakeup
(si existe) cuando un objeto está siendo deserializado. Ofrece más control sobre el proceso de deserialización en comparación con __wakeup
.
__destruct
: Este método se llama cuando un objeto está a punto de ser destruido o cuando el script termina. Se utiliza típicamente para tareas de limpieza, como cerrar manejadores de archivos o conexiones a bases de datos.
__toString
: Este método permite que un objeto sea tratado como una cadena. Puede ser utilizado para leer un archivo u otras tareas basadas en las llamadas a funciones dentro de él, proporcionando efectivamente una representación textual del objeto.
Si miras los resultados, puedes ver que las funciones __wakeup
y __destruct
se llaman cuando el objeto es deserializado. Ten en cuenta que en varios tutoriales encontrarás que la función __toString
se llama al intentar imprimir algún atributo, pero aparentemente eso ya no está sucediendo.
El método __unserialize(array $data)
se llama en lugar de __wakeup()
si está implementado en la clase. Te permite deserializar el objeto proporcionando los datos serializados como un array. Puedes usar este método para deserializar propiedades y realizar cualquier tarea necesaria al deserializar.
Puedes leer un ejemplo de PHP explicado aquí: https://www.notsosecure.com/remote-code-execution-via-php-unserialize/, aquí https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf o aquí https://securitycafe.ro/2015/01/05/understanding-php-object-injection/
Podrías abusar de la funcionalidad de autoload de PHP para cargar archivos php arbitrarios y más:
PHP - Deserialization + Autoload ClassesSi por alguna razón deseas serializar un valor como una referencia a otro valor serializado, puedes:
PHPGGC puede ayudarte a generar payloads para abusar de las deserializaciones de PHP.
Ten en cuenta que en varios casos no podrás encontrar una forma de abusar de una deserialización en el código fuente de la aplicación, pero podrías abusar del código de extensiones PHP externas.
Así que, si puedes, revisa el phpinfo()
del servidor y busca en internet (e incluso en los gadgets de PHPGGC) algunos posibles gadgets que podrías abusar.
Si has encontrado un LFI que solo está leyendo el archivo y no ejecutando el código php dentro de él, por ejemplo, usando funciones como file_get_contents(), fopen(), file() o file_exists(), md5_file(), filemtime() o filesize(). Puedes intentar abusar de una deserialización que ocurre al leer un archivo usando el protocolo phar. Para más información, lee el siguiente post:
phar:// deserializationCuando el objeto se deserializa, se ejecutará la función ___reduce____. Cuando se explota, el servidor podría devolver un error.
Antes de verificar la técnica de bypass, intenta usar print(base64.b64encode(pickle.dumps(P(),2)))
para generar un objeto que sea compatible con python2 si estás ejecutando python3.
Para más información sobre cómo escapar de pickle jails consulta:
Bypass Python sandboxesLa siguiente página presenta la técnica para abusar de una deserialización insegura en bibliotecas de yamls de python y termina con una herramienta que se puede usar para generar cargas útiles de deserialización RCE para Pickle, PyYAML, jsonpickle y ruamel.yaml:
Python Yaml DeserializationJS no tiene funciones "mágicas" como PHP o Python que se ejecutan solo por crear un objeto. Pero tiene algunas funciones que son frecuentemente utilizadas incluso sin ser llamadas directamente como toString
, valueOf
, toJSON
.
Si abusas de una deserialización, puedes comprometer estas funciones para ejecutar otro código (potencialmente abusando de contaminaciones de prototipos) podrías ejecutar código arbitrario cuando sean llamadas.
Otra manera "mágica" de llamar a una función sin llamarla directamente es comprometiendo un objeto que es devuelto por una función asíncrona (promesa). Porque, si transformas ese objeto de retorno en otra promesa con una propiedad llamada "then" de tipo función, será ejecutado solo porque es devuelto por otra promesa. Sigue este enlace para más información.
__proto__
y contaminación de prototype
Si quieres aprender sobre esta técnica echa un vistazo al siguiente tutorial:
NodeJS - __proto__ & prototype PollutionEsta biblioteca permite serializar funciones. Ejemplo:
El objeto serializado se verá así:
Puedes ver en el ejemplo que cuando una función es serializada, el flag _$$ND_FUNC$$_
se añade al objeto serializado.
Dentro del archivo node-serialize/lib/serialize.js
puedes encontrar el mismo flag y cómo el código lo está utilizando.
Como puedes ver en el último fragmento de código, si se encuentra el flag, se utiliza eval
para deserializar la función, así que básicamente la entrada del usuario se está utilizando dentro de la función eval
.
Sin embargo, simplemente serializar una función no la ejecutará, ya que sería necesario que alguna parte del código llame a y.rce
en nuestro ejemplo y eso es altamente improbable.
De todos modos, podrías modificar el objeto serializado agregando algunos paréntesis para que la función serializada se ejecute automáticamente cuando el objeto sea deserializado.
En el siguiente fragmento de código nota el último paréntesis y cómo la función unserialize
ejecutará automáticamente el código:
Como se indicó anteriormente, esta biblioteca obtendrá el código después de _$$ND_FUNC$$_
y lo ejecutará usando eval
. Por lo tanto, para auto-ejecutar código puedes eliminar la parte de creación de la función y el último paréntesis y simplemente ejecutar un oneliner de JS como en el siguiente ejemplo:
Puedes encontrar aquí más información sobre cómo explotar esta vulnerabilidad.
Un aspecto notable de funcster es la inaccesibilidad de objetos incorporados estándar; caen fuera del alcance accesible. Esta restricción impide la ejecución de código que intenta invocar métodos en objetos incorporados, lo que lleva a excepciones como "ReferenceError: console is not defined"
cuando se utilizan comandos como console.log()
o require(something)
.
A pesar de esta limitación, la restauración del acceso completo al contexto global, incluidos todos los objetos incorporados estándar, es posible a través de un enfoque específico. Al aprovechar el contexto global directamente, se puede eludir esta restricción. Por ejemplo, el acceso se puede restablecer utilizando el siguiente fragmento:
Para más información, lee esta fuente.
El paquete serialize-javascript está diseñado exclusivamente para propósitos de serialización, careciendo de cualquier capacidad de deserialización incorporada. Los usuarios son responsables de implementar su propio método para la deserialización. Un uso directo de eval
es sugerido por el ejemplo oficial para deserializar datos serializados:
Si esta función se utiliza para deserializar objetos, puedes explotarlo fácilmente:
Para más información, lea esta fuente.
En las siguientes páginas puedes encontrar información sobre cómo abusar de esta biblioteca para ejecutar comandos arbitrarios:
En Java, los callbacks de deserialización se ejecutan durante el proceso de deserialización. Esta ejecución puede ser explotada por atacantes que crean cargas útiles maliciosas que activan estos callbacks, lo que lleva a la posible ejecución de acciones dañinas.
Para identificar posibles vulnerabilidades de serialización en la base de código, busca:
Clases que implementen la interfaz Serializable
.
Uso de java.io.ObjectInputStream
, readObject
, readUnshare
funciones.
Presta especial atención a:
XMLDecoder
utilizado con parámetros definidos por usuarios externos.
El método fromXML
de XStream
, especialmente si la versión de XStream es menor o igual a 1.46, ya que es susceptible a problemas de serialización.
ObjectInputStream
acoplado con el método readObject
.
Implementación de métodos como readObject
, readObjectNodData
, readResolve
, o readExternal
.
ObjectInputStream.readUnshared
.
Uso general de Serializable
.
Para pruebas de caja negra, busca firmas específicas o "Bytes Mágicos" que denoten objetos serializados de Java (originados de ObjectInputStream
):
Patrón hexadecimal: AC ED 00 05
.
Patrón Base64: rO0
.
Encabezados de respuesta HTTP con Content-type
establecido en application/x-java-serialized-object
.
Patrón hexadecimal que indica compresión previa: 1F 8B 08 00
.
Patrón Base64 que indica compresión previa: H4sIA
.
Archivos web con la extensión .faces
y el parámetro faces.ViewState
. Descubrir estos patrones en una aplicación web debería provocar un examen como se detalla en el post sobre la deserialización de Java JSF ViewState.
Si quieres aprender cómo funciona un exploit de deserialización en Java deberías echar un vistazo a Deserialización Básica en Java, Deserialización DNS en Java, y Carga Útil de CommonsCollection1.
Puedes verificar si hay alguna aplicación instalada con vulnerabilidades conocidas.
Podrías intentar verificar todas las bibliotecas conocidas por ser vulnerables y que Ysoserial puede proporcionar un exploit. O podrías revisar las bibliotecas indicadas en Java-Deserialization-Cheat-Sheet. También podrías usar gadgetinspector para buscar posibles cadenas de gadgets que puedan ser explotadas. Al ejecutar gadgetinspector (después de construirlo), no te preocupes por las toneladas de advertencias/errores que está generando y déjalo terminar. Escribirá todos los hallazgos en gadgetinspector/gadget-results/gadget-chains-año-mes-día-hora-min.txt. Por favor, ten en cuenta que gadgetinspector no creará un exploit y puede indicar falsos positivos.
Usando la extensión de Burp gadgetprobe puedes identificar qué bibliotecas están disponibles (e incluso las versiones). Con esta información podría ser más fácil elegir un payload para explotar la vulnerabilidad.
Lee esto para aprender más sobre GadgetProbe.
GadgetProbe se centra en deserializaciones de ObjectInputStream
.
Usando la extensión de Burp Java Deserialization Scanner puedes identificar bibliotecas vulnerables explotables con ysoserial y explotarlas.
Lee esto para aprender más sobre Java Deserialization Scanner.
Java Deserialization Scanner se centra en deserializaciones de ObjectInputStream
.
También puedes usar Freddy para detectar vulnerabilidades de deserialización en Burp. Este plugin detectará no solo vulnerabilidades relacionadas con ObjectInputStream
sino también vulnerabilidades de bibliotecas de deserialización de Json y Yml. En modo activo, intentará confirmarlas usando payloads de sleep o DNS.
Puedes encontrar más información sobre Freddy aquí.
Prueba de Serialización
No todo se trata de verificar si alguna biblioteca vulnerable es utilizada por el servidor. A veces podrías ser capaz de cambiar los datos dentro del objeto serializado y eludir algunas verificaciones (quizás otorgándote privilegios de administrador dentro de una webapp). Si encuentras un objeto serializado de java siendo enviado a una aplicación web, puedes usar SerializationDumper para imprimir en un formato más legible para humanos el objeto de serialización que se envía. Saber qué datos estás enviando facilitaría su modificación y eludir algunas verificaciones.
La herramienta principal para explotar deserializaciones de Java es ysoserial (descargar aquí). También puedes considerar usar ysoseral-modified que te permitirá usar comandos complejos (con pipes, por ejemplo).
Ten en cuenta que esta herramienta está enfocada en explotar ObjectInputStream
.
Yo comenzaría usando el payload "URLDNS" antes de un payload RCE para probar si la inyección es posible. De todos modos, ten en cuenta que tal vez el payload "URLDNS" no funcione, pero otro payload RCE sí.
Cuando se crea una carga útil para java.lang.Runtime.exec() no se pueden usar caracteres especiales como ">" o "|" para redirigir la salida de una ejecución, "$()" para ejecutar comandos o incluso pasar argumentos a un comando separados por espacios (puedes hacer echo -n "hello world"
pero no puedes hacer python2 -c 'print "Hello world"'
). Para codificar correctamente la carga útil, podrías usar esta página web.
Siéntete libre de usar el siguiente script para crear todas las posibles cargas útiles de ejecución de código para Windows y Linux y luego probarlas en la página web vulnerable:
Puedes usar https://github.com/pwntester/SerialKillerBypassGadgetCollection junto con ysoserial para crear más exploits. Más información sobre esta herramienta en las diapositivas de la charla donde se presentó la herramienta: https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1
marshalsec se puede usar para generar payloads para explotar diferentes Json y Yml bibliotecas de serialización en Java.
Para compilar el proyecto, necesitaba agregar estas dependencias a pom.xml
:
Instala maven, y compila el proyecto:
Lee más sobre esta biblioteca Java JSON: https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html
Si quieres probar algunos payloads de ysoserial puedes ejecutar esta webapp: https://github.com/hvqzao/java-deserialize-webapp
Java utiliza mucha serialización para varios propósitos como:
Solicitudes HTTP: La serialización se emplea ampliamente en la gestión de parámetros, ViewState, cookies, etc.
RMI (Invocación de Métodos Remotos): El protocolo RMI de Java, que se basa completamente en la serialización, es un pilar para la comunicación remota en aplicaciones Java.
RMI sobre HTTP: Este método es comúnmente utilizado por aplicaciones web de cliente grueso basadas en Java, utilizando la serialización para todas las comunicaciones de objetos.
JMX (Extensiones de Gestión de Java): JMX utiliza la serialización para transmitir objetos a través de la red.
Protocolos Personalizados: En Java, la práctica estándar implica la transmisión de objetos Java en bruto, lo que se demostrará en ejemplos de explotación próximos.
Una clase que implementa Serializable
puede implementar como transient
cualquier objeto dentro de la clase que no debería ser serializable. Por ejemplo:
En escenarios donde ciertos objetos deben implementar la interfaz Serializable
debido a la jerarquía de clases, existe el riesgo de deserialización no intencionada. Para prevenir esto, asegúrese de que estos objetos no sean deserializables definiendo un método readObject()
final
que lance consistentemente una excepción, como se muestra a continuación:
Personalizar java.io.ObjectInputStream
es un enfoque práctico para asegurar los procesos de deserialización. Este método es adecuado cuando:
El código de deserialización está bajo tu control.
Las clases esperadas para la deserialización son conocidas.
Sobrescribe el resolveClass()
método para limitar la deserialización solo a las clases permitidas. Esto previene la deserialización de cualquier clase excepto aquellas explícitamente permitidas, como en el siguiente ejemplo que restringe la deserialización solo a la clase Bicycle
:
Usando un Agente de Java para Mejora de Seguridad ofrece una solución alternativa cuando la modificación del código no es posible. Este método se aplica principalmente para bloquear clases dañinas, utilizando un parámetro de JVM:
Proporciona una forma de asegurar la deserialización de manera dinámica, ideal para entornos donde los cambios de código inmediatos son imprácticos.
Consulta un ejemplo en rO0 by Contrast Security
Implementando Filtros de Serialización: Java 9 introdujo filtros de serialización a través de la ObjectInputFilter
interface, proporcionando un mecanismo poderoso para especificar criterios que los objetos serializados deben cumplir antes de ser deserializados. Estos filtros se pueden aplicar globalmente o por flujo, ofreciendo un control granular sobre el proceso de deserialización.
Para utilizar filtros de serialización, puedes establecer un filtro global que se aplique a todas las operaciones de deserialización o configurarlo dinámicamente para flujos específicos. Por ejemplo:
Aprovechando Bibliotecas Externas para una Mayor Seguridad: Bibliotecas como NotSoSerial, jdeserialize y Kryo ofrecen características avanzadas para controlar y monitorear la deserialización de Java. Estas bibliotecas pueden proporcionar capas adicionales de seguridad, como la creación de listas blancas o negras de clases, el análisis de objetos serializados antes de la deserialización e implementar estrategias de serialización personalizadas.
NotSoSerial intercepta los procesos de deserialización para prevenir la ejecución de código no confiable.
jdeserialize permite el análisis de objetos Java serializados sin deserializarlos, ayudando a identificar contenido potencialmente malicioso.
Kryo es un marco de serialización alternativo que enfatiza la velocidad y eficiencia, ofreciendo estrategias de serialización configurables que pueden mejorar la seguridad.
Charla sobre deserialización y ysoserial: http://frohoff.github.io/appseccali-marshalling-pickles/
Charla sobre gadgetinspector: https://www.youtube.com/watch?v=wPbW6zQ52w8 y diapositivas: https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf
Documento de Marshalsec: https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true
Deserializaciones CVEs: https://paper.seebug.org/123/
Encuentra qué es Inyección JNDI, cómo abusar de ella a través de RMI, CORBA y LDAP y cómo explotar log4shell (y un ejemplo de esta vulnerabilidad) en la siguiente página:
JNDI - Java Naming and Directory Interface & Log4ShellLa API de Servicio de Mensajes de Java (JMS) es una API de middleware orientada a mensajes de Java para enviar mensajes entre dos o más clientes. Es una implementación para manejar el problema productor-consumidor. JMS es parte de la Plataforma Java, Edición Empresarial (Java EE), y fue definida por una especificación desarrollada en Sun Microsystems, pero que desde entonces ha sido guiada por el Proceso de Comunidad Java. Es un estándar de mensajería que permite a los componentes de aplicación basados en Java EE crear, enviar, recibir y leer mensajes. Permite que la comunicación entre diferentes componentes de una aplicación distribuida sea débilmente acoplada, confiable y asíncrona. (De Wikipedia).
Hay varios productos que utilizan este middleware para enviar mensajes:
Entonces, básicamente hay un montón de servicios que utilizan JMS de manera peligrosa. Por lo tanto, si tienes suficientes privilegios para enviar mensajes a estos servicios (generalmente necesitarás credenciales válidas), podrías ser capaz de enviar objetos maliciosos serializados que serán deserializados por el consumidor/suscriptor. Esto significa que en esta explotación todos los clientes que vayan a usar ese mensaje se infectarán.
Debes recordar que incluso si un servicio es vulnerable (porque está deserializando de manera insegura la entrada del usuario), aún necesitas encontrar gadgets válidos para explotar la vulnerabilidad.
La herramienta JMET fue creada para conectar y atacar estos servicios enviando varios objetos maliciosos serializados utilizando gadgets conocidos. Estos exploits funcionarán si el servicio sigue siendo vulnerable y si alguno de los gadgets utilizados está dentro de la aplicación vulnerable.
Charla de JMET: https://www.youtube.com/watch?v=0h8DWiOWGGA
En el contexto de .Net, los exploits de deserialización operan de manera similar a los encontrados en Java, donde se explotan gadgets para ejecutar código específico durante la deserialización de un objeto.
El código fuente debe ser inspeccionado en busca de ocurrencias de:
TypeNameHandling
JavaScriptTypeResolver
El enfoque debe estar en los serializadores que permiten que el tipo sea determinado por una variable bajo control del usuario.
La búsqueda debe dirigirse a la cadena codificada en Base64 AAEAAAD///// o cualquier patrón similar que pueda ser deserializado en el lado del servidor, otorgando control sobre el tipo a deserializar. Esto podría incluir, pero no se limita a, estructuras JSON o XML que presenten TypeObject
o $type
.
En este caso, puedes usar la herramienta ysoserial.net para crear los exploits de deserialización. Una vez descargado el repositorio git, deberías compilar la herramienta usando Visual Studio, por ejemplo.
Si deseas aprender sobre cómo ysoserial.net crea su exploit, puedes consultar esta página donde se explica el gadget ObjectDataProvider + ExpandedWrapper + Json.Net formatter.
Las principales opciones de ysoserial.net son: --gadget
, --formatter
, --output
y --plugin
.
--gadget
se utiliza para indicar el gadget a abusar (indicar la clase/función que será abusada durante la deserialización para ejecutar comandos).
--formatter
, se utiliza para indicar el método para serializar el exploit (necesitas saber qué biblioteca está utilizando el back-end para deserializar la carga y usar la misma para serializarla).
--output
se utiliza para indicar si deseas el exploit en crudo o codificado en base64. Ten en cuenta que ysoserial.net codificará la carga utilizando UTF-16LE (codificación utilizada por defecto en Windows), así que si obtienes el crudo y simplemente lo codificas desde una consola de linux, podrías tener algunos problemas de compatibilidad de codificación que impedirán que el exploit funcione correctamente (en la caja JSON de HTB, la carga funcionó tanto en UTF-16LE como en ASCII, pero esto no significa que siempre funcionará).
--plugin
ysoserial.net admite plugins para crear exploits para marcos específicos como ViewState.
--minify
proporcionará una carga útil más pequeña (si es posible).
--raf -f Json.Net -c "anything"
Esto indicará todos los gadgets que se pueden usar con un formateador proporcionado (Json.Net
en este caso).
--sf xml
puedes indicar un gadget (-g
) y ysoserial.net buscará formateadores que contengan "xml" (sin distinción de mayúsculas y minúsculas).
Ejemplos de ysoserial para crear exploits:
ysoserial.net también tiene un parámetro muy interesante que ayuda a entender mejor cómo funciona cada exploit: --test
Si indicas este parámetro, ysoserial.net intentará el exploit localmente, así que puedes probar si tu payload funcionará correctamente.
Este parámetro es útil porque si revisas el código encontrarás fragmentos de código como el siguiente (de ObjectDataProviderGenerator.cs):
Esto significa que para probar la explotación, el código llamará a serializersHelper.JsonNet_deserialize
En el código anterior es vulnerable al exploit creado. Así que si encuentras algo similar en una aplicación .Net, significa que probablemente esa aplicación también sea vulnerable.
Por lo tanto, el --test
permite entender qué fragmentos de código son vulnerables al exploit de deserialización que ysoserial.net puede crear.
Echa un vistazo a este POST sobre cómo intentar explotar el parámetro __ViewState de .Net para ejecutar código arbitrario. Si ya conoces los secretos utilizados por la máquina víctima, lee este post para saber cómo ejecutar código.
Para mitigar los riesgos asociados con la deserialización en .Net:
Evita permitir que los flujos de datos definan sus tipos de objeto. Utiliza DataContractSerializer
o XmlSerializer
cuando sea posible.
Para JSON.Net
, establece TypeNameHandling
en None
: %%%TypeNameHandling = TypeNameHandling.None%%%
Evita usar JavaScriptSerializer
con un JavaScriptTypeResolver
.
Limita los tipos que pueden ser deserializados, entendiendo los riesgos inherentes con los tipos de .Net, como System.IO.FileInfo
, que puede modificar las propiedades de los archivos del servidor, lo que podría llevar a ataques de denegación de servicio.
Ten cuidado con los tipos que tienen propiedades riesgosas, como System.ComponentModel.DataAnnotations.ValidationException
con su propiedad Value
, que puede ser explotada.
Controla de manera segura la instanciación de tipos para evitar que los atacantes influyan en el proceso de deserialización, lo que haría que incluso DataContractSerializer
o XmlSerializer
sean vulnerables.
Implementa controles de lista blanca utilizando un SerializationBinder
personalizado para BinaryFormatter
y JSON.Net
.
Mantente informado sobre gadgets de deserialización inseguros conocidos dentro de .Net y asegúrate de que los deserializadores no instancien tales tipos.
Aísla el código potencialmente riesgoso del código con acceso a internet para evitar exponer gadgets conocidos, como System.Windows.Data.ObjectDataProvider
en aplicaciones WPF, a fuentes de datos no confiables.
Documento sobre deserialización JSON en Java y .Net: https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf, charla: https://www.youtube.com/watch?v=oUAeWhW5b8c y diapositivas: https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf
En Ruby, la serialización se facilita mediante dos métodos dentro de la biblioteca marshal. El primer método, conocido como dump, se utiliza para transformar un objeto en un flujo de bytes. Este proceso se conoce como serialización. Por el contrario, el segundo método, load, se emplea para revertir un flujo de bytes de nuevo a un objeto, un proceso conocido como deserialización.
Para asegurar objetos serializados, Ruby emplea HMAC (Código de Autenticación de Mensajes Basado en Hash), asegurando la integridad y autenticidad de los datos. La clave utilizada para este propósito se almacena en una de varias ubicaciones posibles:
config/environment.rb
config/initializers/secret_token.rb
config/secrets.yml
/proc/self/environ
Cadena de gadgets de deserialización genérica de Ruby 2.X a RCE (más información en https://www.elttam.com/blog/ruby-deserialization/):
Otro cadena RCE para explotar Ruby On Rails: https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/
Como se explica en este informe de vulnerabilidad, si alguna entrada no sanitizada de un usuario llega al método .send()
de un objeto ruby, este método permite invocar cualquier otro método del objeto con cualquier parámetro.
Por ejemplo, llamar a eval y luego código ruby como segundo parámetro permitirá ejecutar código arbitrario:
Además, si solo un parámetro de .send()
es controlado por un atacante, como se mencionó en el escrito anterior, es posible llamar a cualquier método del objeto que no necesite argumentos o cuyos argumentos tengan valores predeterminados.
Para esto, es posible enumerar todos los métodos del objeto para encontrar algunos métodos interesantes que cumplan con esos requisitos.
Esta técnica fue tomada de esta publicación de blog.
Hay otras bibliotecas de Ruby que se pueden usar para serializar objetos y, por lo tanto, que podrían ser abusadas para obtener RCE durante una deserialización insegura. La siguiente tabla muestra algunas de estas bibliotecas y el método que llaman de la biblioteca cargada cada vez que se deserializa (función a abusar para obtener RCE básicamente):
Biblioteca
Datos de entrada
Método de inicio dentro de la clase
Marshal (Ruby)
Binario
_load
Oj
JSON
hash
(la clase debe ser puesta en hash(mapa) como clave)
Ox
XML
hash
(la clase debe ser puesta en hash(mapa) como clave)
Psych (Ruby)
YAML
hash
(la clase debe ser puesta en hash(mapa) como clave)
init_with
JSON (Ruby)
JSON
json_create
([ver notas sobre json_create al final](#table-vulnerable-sinks))
Ejemplo básico:
En el caso de intentar abusar de Oj, fue posible encontrar una clase gadget que dentro de su función hash
llamará a to_s
, que llamará a spec, que llamará a fetch_path, lo que fue posible hacer que obtuviera una URL aleatoria, dando un gran detector de este tipo de vulnerabilidades de deserialización no sanitizadas.
Además, se encontró que con la técnica anterior también se crea una carpeta en el sistema, que es un requisito para abusar de otro gadget con el fin de transformar esto en un RCE completo con algo como:
Consulta más detalles en la publicación original.
Aprende y practica Hacking en AWS:HackTricks Training AWS Red Team Expert (ARTE) Aprende y practica Hacking en GCP: HackTricks Training GCP Red Team Expert (GRTE)