Catégories
Midnight Flag Réseau Write-ups

Midnight Flag – Réseau

Dans ce write-up vous trouverez tous les challenges de la catégorie réseau du CTF Midnight Flag que nous avons résolus avec l’équipe Arn’Hack.

Fichiers des challenges

Do you know ARP

Dans ce premier challenge on se retrouve avec une capture .pcapng qu’on peut alors ouvrir avec Wireshark.

Capture ouverte dans Wireshark

On descend dans les requêtes ARP à l’aide de la flèche directionnelle du clavier tout en gardant un oeil sur la partie dump hexadécimal et on remarque qu’à partir d’un moment un seul octet change d’une requête à l’autre.

1ère requête avec un changement
2ème requête avec un changement
3ème requête avec un changement

Méthode 1 – Recopier à la main (pas fun)

La méthode la plus simple consiste à recopier à la main le caractère modifié dans chaque requête. C’est un peu long mais au moins on est sûr que ça marche 😁.

Après quelques minutes on obtient alors le flag MCTF{M@c_P0w3r}.

Méthode 2 – One liner avec tshark

On peut également penser à automatiser l’extraction du flag. Un moyen très pratique de faire ça est d’utiliser tshark qui est en gros la version en lignes de commandes de Wireshark. Cette solution est basée sur la solution de Mahal alors merci à lui 🙂.

On commence par remarquer que l’octet qui change d’une requête à l’autre est le dernier octet de l’adresse MAC de destination.

L’octet qui change est le dernier de l’adresse MAC de destination

On va donc commencer par récupérer tous les champs correspondant à la “target MAC address” de toutes les requêtes, le tout avec tshark.

$ tshark -r Do_you_know_ARP.pcapng -T fields -e arp.dst.hw_mac
 fa:ce:b0:0c:de:ad
 fa:ce:b0:0c:de:ad
 [...]
 fa:ce:b0:0c:de:ad
 fa:ce:b0:0c:de:ad
 fa:ce:b0:0c:de:ad
 fa:ce:b0:0c:de:4d
 fa:ce:b0:0c:de:43
 fa:ce:b0:0c:de:54
 fa:ce:b0:0c:de:46
 fa:ce:b0:0c:de:7b
 fa:ce:b0:0c:de:4d
 fa:ce:b0:0c:de:40
 fa:ce:b0:0c:de:63
 fa:ce:b0:0c:de:5f
 fa:ce:b0:0c:de:50
 fa:ce:b0:0c:de:30
 fa:ce:b0:0c:de:77
 fa:ce:b0:0c:de:33
 fa:ce:b0:0c:de:72
 fa:ce:b0:0c:de:7d
 fa:ce:b0:0c:de:ad
 fa:ce:b0:0c:de:ad
 [...]

A partir de là on va commencer par supprimer les lignes sur lesquelles le dernier octet de l’adresse mac est 0xad, soit celles qui n’ont pas été modifiées, en utilisant grep.

$ tshark -r Do_you_know_ARP.pcapng -T fields -e arp.dst.hw_mac | grep -v 'ad$'
 fa:ce:b0:0c:de:4d
 fa:ce:b0:0c:de:43
 fa:ce:b0:0c:de:54
 fa:ce:b0:0c:de:46
 fa:ce:b0:0c:de:7b
 fa:ce:b0:0c:de:4d
 fa:ce:b0:0c:de:40
 fa:ce:b0:0c:de:63
 fa:ce:b0:0c:de:5f
 fa:ce:b0:0c:de:50
 fa:ce:b0:0c:de:30
 fa:ce:b0:0c:de:77
 fa:ce:b0:0c:de:33
 fa:ce:b0:0c:de:72
 fa:ce:b0:0c:de:7d

On va ensuite garder uniquement le dernier octet des adresses MAC en utilisant sed.

$ tshark -r Do_you_know_ARP.pcapng -T fields -e arp.dst.hw_mac | grep -v 'ad$' | sed 's/.*://'
 4d
 43
 54
 46
 7b
 4d
 40
 63
 5f
 50
 30
 77
 33
 72
 7d

Enfin, on va convertir les caractères hexadécimaux directement en ASCII avec xxd. On récupère ainsi un beau one liner qui nous affiche le flag directement 😁.

$ tshark -r Do_you_know_ARP.pcapng -T fields -e arp.dst.hw_mac | grep -v 'ad$' | sed 's/.*://' | xxd -r -p
MCTF{M@c_P0w3r}

Codage Couches Basses

Dans ce challenge on se retrouve avec un fichier contenant du binaire.

0110100110100110011010010101101001101010011001010110100101101001011010101001101001101001011010100101101001010101011001101010101001101001101001100101101001100101011010011010100101100101010110100110100110010101010110100101101001011010011001100110101001100101010110100101101001100110010110010110101010100110

L’énoncé nous donne l’indication suivante.

Vous avez intercepté des échanges sur un
réseau legacy Ethernet 10mbps.
Pourrez vous récupérer les données encodées ?

Après quelques recherches (ou si on a vu ça en cours sans s’endormir) on se rend compte que l’Ethernet fonction avec le “codage de Manchester” sur les paires torsadées.

On peut donc trouver un solveur sur internet par flemme.

Décodage de la trame avec dcode.fr

Et on peut enfin convertir le binaire en ASCII encore avec un solveur en ligne par flemme et on récupère le flag : mctf{g0_m4nCh35t3R}.

Endianness

Le fichier de ce challenge est une capture .pcapng que l’on peut alors ouvrir dans Wireshark. A première vue, toutes les requêtes sont globalement identiques.

Requêtes toutes semblables

Cependant en faisant défiler les requêtes tout en regardant le dump hexadécimal on remarque deux requêtes (une requête et sa réponse associée) avec beaucoup plus de données que les autres.

Requête et réponse associée avec un gros volume de données

les données sont en hex dans le plaintext, on peut alors copier le contenu comme du texte meme si c’est en réalité encore de l’hexa.

Copie des données de la requête

On peut alors convertir cet hexa en ASCII avec un convertisseur online par exemple.

Hexadécimal convertit en ASCII

Le flag est à l’envers on peut alors le reverse grâce à Python.

$ python
Python 3.9.4 (default, Apr  5 2021, 01:50:46) 
 [Clang 12.0.0 (clang-1200.0.32.29)] on darwin
 Type "help", "copyright", "credits" or "license" for more information.
>>> "}lam1c3dax3h_naht_yx3s_3r0m_si_yran1B{FTCM"[::-1]
'MCTF{B1nary_is_m0r3_s3xy_than_h3xad3c1mal}'         

On récupère ainsi le flag : MCTF{B1nary_is_m0r3_s3xy_than_h3xad3c1mal}.

Indicateur 2 Compromis

Dans ce challenge on retrouve une capture .pcap qu’on peut alors ouvrir dans Wireshark. On remarque beaucoup d’informations et de requêtes, la trame fait d’ailleurs plus de 35 Mo.

On observe beaucoup d’informations dans la trame

On remarque alors beaucoup de traffic SSL/TLS, du TCP sur le port 443 : on est probablement ici sur une navigation web en HTTPS.

Après avoir dérouler les requêtes à la main pendant un moment on ne remarque pas grand chose avant un moment alors on peut avoir l’idée de trier les requêtes par protocoles pour voir si on trouve quelque chose d’autre.

Requêtes triées par protocoles

On a donc quelques requêtes ARP sans grand intérêt, des requêtes DHCP, DNS pour le résolution des noms de domaines des sites visités (microsoft.com, github.com, cdn.kernel.org …), les requêtes TLS/SSL, TCP… On commence à désespérer quand à la fin du fichier on aperçoit de multiples requêtes UDP avec pour certaines des messages en base64 !

Requêtes UDP avec des données encodées en base64

On décode alors le premier message.

$ echo TUNURntuZXZlcl9nb25uYV9naXZlX3lvdV91cA== | base64 -D
MCTF{never_gonna_give_you_up

Vous la sentez la douille arriver (moi oui) ? Bon on va donc chercher un moyen d’extraire toutes ces données en base64, toutes les décoder et peut être qu’avec un peu de chance le bon flag se trouvera parmi ceux-là !

On commence par extraire tous les champs data de toutes les requêtes de protocole UDP avec tshark.

$ tshark -nr Indicateur_2_Compromis.pcap -Y udp -T fields -e data
 58
 54554e55526e74755a585a6c636c396e623235755956396e61585a6c58336c766456393163413d3d
 58
 58
 58
 58
 58
 54554e55526e74756233526661585266626d393058326c3066513d3d
 58
 58
 58
 58
 58
 54554e55526e74755a585a6c636c39735a585266655739315832527664323539
 58
 58
 58
 58
 58
 54554e55526e74356233566659584a6c58324a685a463968644639706448303d
 58
 58
 58
 58
 58
 54554e55526e7469636e56305a575a76636d4e6c58326c7a5832357664463930614756665957357a6432567966513d3d
 58
 58
 58
 58
 58

On remarque alors de grands espaces et des trames sans données intéressantes contenant uniquement 0x58. Avec grep on peut donc supprimer les lignes contenant uniquement “58” ainsi que celles contenant uniquement des retours à la ligne.

$ tshark -nr Indicateur_2_Compromis.pcap -Y udp -T fields -e data | grep -v "^58\$" | grep -v "^\$"
 54554e55526e74755a585a6c636c396e623235755956396e61585a6c58336c766456393163413d3d
 54554e55526e74756233526661585266626d393058326c3066513d3d
 54554e55526e74755a585a6c636c39735a585266655739315832527664323539
 54554e55526e74356233566659584a6c58324a685a463968644639706448303d
 54554e55526e7469636e56305a575a76636d4e6c58326c7a5832357664463930614756665957357a6432567966513d3d
 54554e55526e746a6147566a613139336158526f5833526f5a5639686458526f62334a7064476c6c6333303d
 54554e55526e746f59585a6c58336c7664563930636d6c6c5a463942546c4e54535639355a58512f
 54554e55526e74795a57467362486c66655739315833526f615735725033303d
 54554e55526e744a54304e66556c396d64573539
 54554e55526e7468636d56666557393158334a6c595778736556397a64584a6c5033303d
 54554e55526e74755a585a6c636c396e62323575595639745957746c58336c766456396a636e6c39
 54554e55526e74755a585a6c636c396e62323575595639305a5778735832466662476c6c583246755a46396f64584a3058336c766458303d
 54554e55526e746f64485277637a6f764c336433647935356233563064574a6c4c6d4e76625339335958526a6144393250575252647a52334f56646e57474e5266513d3d
 54554e55526e74756233426c5832357663475666626d39775a58303d
 54554e55526e74795a57466b5833526f5a56396a6248566c6333303d
 54554e55526e747562335266644768686446396c59584e3566513d3d
 54554e55526e747058325276583235766446393061476c756131397a6233303d
 54554e55526e746a6147566a613139336158526f5833526f5a56396d636d5675593268665958563061485276636d6c306157567a66513d3d
 54554e55526e7470633139706446397a6231396f59584a6b5033303d
 54554e55526e7435623356665a32393058335279623278735a575239
 54554e55526e747a6231396a6247397a5a5639355a585266633239665a6d467966513d3d
 54554e55526e747459586c695a56393061476c7a583239755a58303d
 54554e55526e743061476c7a58324e6f595778735a57356e5a5639706331397a6231396c59584e3566513d3d
 54554e55526e7468636d56666557393158325675616d39356157356e5833526f61584e66513152475033303d
 54554e55526e747562335266644768686446396f59584a6b66513d3d
 54554e55526e7430636e6c665957646861573539
 54554e55526e74766233427a615756666557393149475a6861577839
 54554e55526e74755a585a6c636c396e623235755956396e61585a6c58336c766456393163413d3d
 54554e55526e74756233526661585266626d393058326c3066513d3d

Nickel ! On peut alors stocker tout ça dans un fichier que l’on appellera “trames.txt”.

$ tshark -nr Indicateur_2_Compromis.pcap -Y udp -T fields -e data | grep -v "^58\$" | grep -v "^\$" > trames.txt

On écrit ensuite un petit script bash qui permettra, pour chaque ligne, de transformer l’hexadécimal en base64 puis de décoder cette base64.

#!/bin/bash

while read p; do
  echo $p | xxd -p -r | base64 -D
  echo
done < trames.txt

On peut alors lancer notre script.

$ vim script.sh
$ chmod +x ./script.sh
$ ./script.sh
 MCTF{never_gonna_give_you_up
 MCTF{not_it_not_it}
 MCTF{never_let_you_down}
 MCTF{you_are_bad_at_it}
 MCTF{bruteforce_is_not_the_answer}
 MCTF{check_with_the_authorities}
 MCTF{have_you_tried_ANSSI_yet?
 MCTF{really_you_think?}
 MCTF{IOC_R_fun}
 MCTF{are_you_really_sure?}
 MCTF{never_gonna_make_you_cry}
 MCTF{never_gonna_tell_a_lie_and_hurt_you}
 MCTF{https://www.youtube.com/watch?v=dQw4w9WgXcQ}
 MCTF{nope_nope_nope}
 MCTF{read_the_clues}
 MCTF{not_that_easy}
 MCTF{i_do_not_think_so}
 MCTF{check_with_the_french_authtorities}
 MCTF{is_it_so_hard?}
 MCTF{you_got_trolled}
 MCTF{so_close_yet_so_far}
 MCTF{maybe_this_one}
 MCTF{this_challenge_is_so_easy}
 MCTF{are_you_enjoying_this_CTF?}
 MCTF{not_that_hard}
 MCTF{try_again}
 MCTF{oopsie_you fail}
 MCTF{never_gonna_give_you_up
 MCTF{not_it_not_it}

On a alors une série d’une trentaine de fake flags. En y regardant de plus près, on en remarque un qui a l’air plus légitime que les autres, on l’essaie et on flag !

Flag du challenge : MCTF{IOC_R_fun}.