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. Dans cet article, je détaille le chemin suivi pour les challenges auxquels j'ai contribué à trouver la solution.
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é sur le [Write-Up du Breizh-Camp 2016 d'Intrinsec](https://securite.intrinsec.com/2016/05/17/breizhctf-2016-write-up-pyjail-1-2-3/).
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 intrusctions 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
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.
### 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 ai 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 utiliser 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 modifier 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*, peut 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.
## Challenges officiels
### 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 luminosité, 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
```
### So easy
Pour ce challenge, nous partions de l'image suivante :
[![Image de départ](/assets/images/posts/ndh-chall_soeasy.png)](/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) :
Ensuite, on peut soit baisser son écran pour lire le texte, soit redimenssioner les images (outil de mise à l'échelle). L'idée étant de réduire de beaucoup réduire la hauteur et d'augmenter beaucoup la largeur :
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 fichier pour les vérifier un à un manuellement. J'ai fais le choix d'automatiser la recherche avec 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.
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). Ce dernier contient des informations en base64. On récupère le binaire associé :
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 luminosité dans GIMP sous Teintes-Saturation, certaines lettres et chiffres apparaissent d'une couleur différente :
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 ?