SE5 IdO sécurité des objets 2025/2026 b2

🌐 TP Infrastructure Réseau 🛜

Introduction

Ce wiki documente la mise en place d’une petite infrastructure réseau pédagogique pour le TP 2025/2026.

L’objectif est de déployer un serveur virtuel sur capbreton, d’y terminer un VLAN privé (ici 409 car je suis a la Zabeth 09), puis d’implanter les services exigés : DHCP, DNS (forwarder + zone locale d’interception), NAT/mascarade, et redirection réseau pour l’HTTP.

Des choix techniques sont explicités à chaque étape (pourquoi tel fichier, telle option, tel service), afin d’argumenter les décisions et permettre la reproductibilité.

Serveur virtuel (17/09)

La VM est créée sur Xen depuis capbreton avec une unique interface reliée à bridgeStudents, conformément au sujet (routage par 172.26.145.251 côté salles projets).

xen-create-image \
  --hostname=SE5.kelbachi \
  --dhcp \
  --bridge=bridgeStudents \
  --dir=/usr/local/xen \
  --size=10GB \
  --dist=daedalus \
  --memory=2G \
  --force

Pourquoi cette commande ?

--bridge=bridgeStudents impose l’unique attachement réseau demandé ; --dist=daedalus assure une base Devuan stable (ifupdown classique) ; les ressources (2 Gio RAM/10 Gio disque) suffisent pour DHCP/DNS/NAT.

Démarrage et accès console :

xl create -c /etc/xen/SE5.kelbachi.cfg
# Ctrl+] pour détacher la console sans éteindre

Adresse routée (réseau des salles projets)

Configuration statique avec passerelle 172.26.145.251. On choisit une IP libre dans la plage fournie (exemple 172.26.145.109/24).

# /etc/network/interfaces (extrait)
auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
    address 172.26.145.109/24
    gateway 172.26.145.251
    dns-nameservers 1.1.1.1 8.8.8.8

Pourquoi une IP statique ?

Le sujet exige un adressage maîtrisé côté salles projets et une route par défaut vers le routeur NAT de la salle. C’est la base pour que la VM accède à Internet et puisse, ensuite, NATer les clients WiFi.

Interface privée (VLAN 409)

Le réseau privé associé à X=09 est 172.16.9.0/24. La VM termine ce VLAN avec l’adresse 172.16.9.1/24 (gateway & DNS pour les clients). Dans notre mise en place, l’interface privée est eth1.

# /etc/network/interfaces (complément)
auto eth1
iface eth1 inet static
    address 172.16.9.1/24

Vérifications :

ip a
ip r
ping -c3 172.26.145.251
ping -c3 8.8.8.8

Point d’accès Cisco – SSID WPA2-PSK (29/09)

Connexion console série (9600 8N1, sans control flow) avec Minicom. Après habilitation, création d’un SSID attaché au VLAN 409.

dot11 ssid SE5-SSID09
  vlan 409
  authentication open
  authentication key-management wpa version 2
  wpa-psk ascii Cisco2025
  exit

interface dot11radio 0
  encryption mode ciphers aes-ccm
  ssid SE5-SSID09
  station-role root
  no shutdown

Nous laissons de cote cette partie car elle n'est pas bloquante pour la suite du TP.

Serveur DHCP (29/09)

Distribution automatisée d’adresses 172.16.9.100–200 aux clients du VLAN 409, avec routeur et DNS pointant vers la VM.

Installation :

apt-get update
apt-get install -y isc-dhcp-server

Configuration :

# /etc/dhcp/dhcpd.conf
default-lease-time 600;
max-lease-time 7200;
authoritative;

subnet 172.16.9.0 netmask 255.255.255.0 {
  range 172.16.9.100 172.16.9.200;
  option routers 172.16.9.1;
  option domain-name-servers 172.16.9.1;
}

Mascarade (NAT) – Accès Internet (29/09)

Activation du routage IPv4 et NAT du réseau 172.16.9.0/24 vers eth0.

sysctl -w net.ipv4.ip_forward=1
sed -i 's/^#\?net\.ipv4\.ip_forward.*/net.ipv4.ip_forward=1/' /etc/sysctl.conf

iptables -t nat -F
iptables -t nat -A POSTROUTING -o eth0 -s 172.16.9.0/24 -j MASQUERADE
iptables -t nat -A POSTROUTING -o eth0 -s 172.16.9.0/24 -j MASQUERADE

iptables -t nat -L -n -v

Pourquoi la mascarade ?

Les clients WiFi utilisent des adresses privées. Le NAT traduit leurs paquets pour qu’ils sortent avec l’IP de la VM côté salles projets.

Sans NAT, pas d’Internet pour le VLAN 409.

Persistance :

apt-get install -y iptables-persistent
netfilter-persistent save

Interception de flux (04/10)

Redirection par DNS (zone locale)

On implémente une zone primaire sur la VM pour rediriger picoctf.org et tous ses sous-domaines vers la VM. Service BIND sous Devuan : nom de service systemd = named.

Déclaration :

# /etc/bind/named.conf.local
zone "picoctf.org" {
    type master;
    file "/etc/bind/db.picoctf.org";
};

Zone :

$TTL  200
@  IN SOA ns.picoctf.org. admin.picoctf.org. (
    2025100403 ; Serial
    3600       ; Refresh
    1800       ; Retry
    604800     ; Expire
    86400 )    ; Minimum

        IN NS  ns.picoctf.org.
ns      IN A   172.16.9.1
@       IN A   172.16.9.1
www     IN CNAME ns

Options (écoute VLAN) :

# /etc/bind/named.conf.options (extrait)
options {
  directory "/var/cache/bind";
  recursion yes;
  allow-query { 172.16.9.0/24; 127.0.0.1; };
  forwarders { 1.1.1.1; 8.8.8.8; };
  listen-on { 172.16.9.1; 127.0.0.1; };
  dnssec-validation auto;
};

Service & vérifs :

systemctl enable named
systemctl restart named
named-checkconf
named-checkzone picoctf.org /etc/bind/db.picoctf.org
dig @127.0.0.1 picoctf.org +short
dig @127.0.0.1 www.picoctf.org +short
dig @127.0.0.1 test.picoctf.org +short   # wildcard

Redirection réseau

Mise en place d’une REDIRECT pour capter le HTTP et le diriger vers un service local.

# Table nat propre
iptables -t nat -F

# Interception HTTP
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-ports 8080

# NAT format TP (409)
iptables -t nat -A POSTROUTING -o eth0 -s 172.16.9.0/24 -j MASQUERADE
iptables -t nat -A POSTROUTING -o eth0 -s 172.16.9.0/24 -j MASQUERADE

iptables -t nat -L -n -v

Serveur Apache sécurisé (08/10)

Dans cette partie, l’objectif est de mettre en place un serveur web sécurisé en HTTPS avec un certificat signé par une autorité locale. J'utilise ici le domaine d’exemple picoctf.org, déjà intercepté par notre DNS.

1. Création d’un certificat auto-signé

Avant toute chose, je génère un certificat auto-signé permettant à Apache de servir du HTTPS localement.

openssl req -x509 -nodes -days 365 \
  -newkey rsa:2048 \
  -keyout /etc/ssl/apache/apache-selfsigned.key \
  -out /etc/ssl/apache/apache-selfsigned.crt \
  -subj "/C=FR/ST=Nord/L=Lille/O=Polytech/CN=picoctf.org"

2. Configuration d’Apache2

Je crée un nouveau fichier de configuration HTTPS dans /etc/apache2/sites-available/secure-site.conf.

<VirtualHost *:443>
    ServerName picoctf
    DocumentRoot /var/www/html

    SSLEngine on
    SSLCertificateFile /etc/apache2/sites-available/apache.crt
    SSLCertificateKeyFile /etc/apache2/sites-available/apache.key

    # Logs SSL
    ErrorLog ${APACHE_LOG_DIR}/ssl-error.log
    CustomLog ${APACHE_LOG_DIR}/ssl-access.log combined
</VirtualHost>

# HTTP vers HTTPS
<VirtualHost *:80>
    ServerName picoctf.org
    Redirect permanent / https://picoctf.org/
</VirtualHost>

Cette configuration active le service sur le port 443 et redirige automatiquement les connexions HTTP vers HTTPS.

3. Création d’une autorité de certification locale

Afin de simuler un certificat signé par une autorité de confiance, je crée une CA interne appelée "Certif".

openssl req -x509 -new -nodes \
  -keyout ca.key -sha256 -days 365 \
  -out ca.crt -subj "/CN=Certif"

4. Signature du certificat Apache avec l’autorité locale

Je commence par créer une demande de signature (CSR) pour le serveur Apache :

openssl req -new -newkey rsa:2048 -nodes \
  -keyout apache.key -out apache.csr \
  -subj "/CN=picoctf.org"

Puis je signe cette requête avec notre autorité Certif :

openssl x509 -req -in apache.csr \
  -CA ca.crt -CAkey ca.key -CAcreateserial \
  -out apache.crt -days 365 -sha256

Je remplace ensuite dans la configuration Apache les fichiers de certificat auto-signés par ceux nouvellement générés :
- /etc/apache2/sites-available/apache.crt
- /etc/apache2/sites-available/apache.key

Redémarrage du service :

a2enmod ssl
a2ensite secure-site.conf
systemctl reload apache2

Machine virtuelle Android

Lorsque je tente d’accéder à https://picoctf.org depuis un appareil Android récent, le certificat de l’autorité “Certif” n’est pas reconnu.

Pour contourner cela, il est possible d’installer une ancienne machine Android (par exemple sous Android 4.x), où l’ajout manuel d’une autorité de certification est encore possible.

Sur cette Android, après quelques ajustements réseau, il est possible d’importer le certificat racine Certif et ainsi naviguer vers le faux site picoctf.org.

Appareil Android physique (08/10)

Enfin, le même test a été reproduit sur la tablette Android 4.4 de mon camarade, une version qui permet encore l’ajout d’autorités de certification manuellement.

En important le fichier `ca.crt` dans les paramètres de sécurité, le site `https://picoctf.org` devient totalement “sécurisé” : le navigateur affiche le cadenas vert , confirmant que la connexion est chiffrée et que le certificat est reconnu par le système.

Problèmes rencontrés

• Console Cisco muette : causée par le flow control. Solution : désactiver hardware & software flow control dans minicom (9600, 8N1, /dev/ttyUSB0).
• Erreur AP cipher not configured : corriger en posant `authentication ... version 2` côté SSID et encryption mode ciphers aes-ccm côté radio.

Partie 2 : Casse d'objets connectés (IoT)

L'objectif est d'intercepter les communications HTTPS de l'application mobile **Nedis SmartLife** pour récupérer la `localKey` de l'alarme. Nous avons exploré une approche logicielle par virtualisation avant de passer à l'approche matérielle.

1. Approche Logicielle : Virtualisation Android

Notre but était de monter une machine virtuelle Android, d'y installer l'application cible, d'obtenir les droits **root**, et d'injecter notre certificat CA système pour permettre l'interception SSL (Man-in-the-Middle).

Phase 1 : Tentatives via QEMU (Ligne de commande)

Nous avons d'abord tenté d'émuler Android "à la main" via QEMU/KVM en utilisant plusieurs images ISO (Android x86 versions 6 à 9). Cette méthode légère permettait théoriquement un contrôle total sur les paramètres de lancement.

Commandes utilisées pour les différents tests :

# Test basique en mode user net
qemu-system-x86_64 -net nic -net user -m 1024 -enable-kvm -display sdl -drive file=android.img,format=raw

# Boot sur ISO pour installation
qemu-system-x86_64 -net nic -net user -m 1024 -enable-kvm -display sdl -drive file=android.img,format=raw -cdrom android-x86-9.0.iso -boot d

# Tentative avancée (USB passthrough et CPU host)
qemu-system-x86_64 \
    -m 2048 \
    -enable-kvm \
    -cpu host \
    -smp 2 \
    -display sdl \
    -drive file=android.img,format=raw,if=virtio \
    -usb \
    -device usb-host,vendorid=0x148f,productid=0x5370

Bilan des tests QEMU

Malgré de multiples tentatives avec différentes ISOs, nous avons rencontré des blocages systématiques rendant l'exploitation impossible :

• **Absence de services Google (GApps) :** Impossible d'installer l'application via le Store.
• **Incompatibilité de version :** Les images Android 4.x/5.x étaient trop anciennes pour l'APK Nedis.
• **Crash à l'installation d'APK :** Certaines images refusaient l'installation manuelle (`adb install`).
• **Impossibilité de Root :** Les versions récentes (Android 9+) verrouillaient la partition système en lecture seule (Read-Only), empêchant l'injection du certificat CA.

Phase 2 : Android Studio (L'artillerie lourde)

Face aux échecs de QEMU, nous sommes passés à **Android Studio** pour bénéficier d'émulateurs (AVD) officiels et plus stables.

1. Installation et Configuration L'archive officielle a été décompressée et installée localement dans le répertoire utilisateur pour contourner les restrictions de droits des machines de TP.

# Installation
sudo mv ~/Downloads/android-studio ~/
sudo chown -R kelbachi ~/android-studio

# Lancement
~/android-studio/bin/studio.sh

Le SDK s'est installé dans : /home/kelbachi/Android/Sdk/.

2. Création de l'AVD et Problème d'Architecture Nous avons tenté de créer un émulateur **Pixel 6 Pro**.

• **Premier essai (Image ARM) :** Nous avons naïvement sélectionné une image système ARM64 pour correspondre à l'architecture native des téléphones.
• **Erreur bloquante :**

AVD's CPU Architecture 'arm64' is not supported by the QEMU2 emulator on x86_64 host

• **Solution :** Nous avons dû basculer sur une image **Google APIs x86_64 (Android 10 / API 29)**.

3. Installation de l'application Nedis L'APK officiel ne fonctionnant pas sur l'architecture x86 (car compilé pour ARM), nous avons récupéré une version compatible via Aptoide (lien : https://nedis-smartlife.en.aptoide.com/app). Sur l'image x86_64, l'application se lance correctement.

Phase 3 : La bataille du Certificat (Root & Système)

Pour intercepter le HTTPS, le certificat CA doit être placé dans /system/etc/security/cacerts/. Cela requiert les droits d'écriture sur la partition système.

Tentative 1 : ADB Root standard

# Préparation du hash du certificat
openssl x509 -inform PEM -subject_hash_old -in ca.crt
# Hash obtenu : 9de4c2c8 -> fichier 9de4c2c8.0

# Tentative d'injection
adb root
adb shell avbctl disable-verification  # Tentative de désactiver Verified Boot
adb reboot
adb wait-for-device root
adb remount
adb push 9de4c2c8.0 /system/etc/security/cacerts/

Résultat

ÉCHEC

adb: error: failed to copy '9de4c2c8.0' to '/system/etc/security/cacerts/': remote write failed: Read-only file system

Sur les images "Production" (Google Play), **dm-verity** empêche toute modification de la partition système, même en root.

Tentative 2 : Démarrage en mode Writable Nous avons tenté de forcer le montage en écriture via les options de l'émulateur en ligne de commande :

~/Android/Sdk/emulator/emulator -avd Pixel_6_Pro_API_29 -writable-system -no-snapshot

Résultat

ÉCHEC PARTIEL

Cette commande permet théoriquement l'écriture, mais nécessite une image système spécifique (non-"Google Play") et rend l'émulateur instable. De plus, les modifications ne sont pas persistantes au redémarrage suivant, rendant l'installation du certificat inopérante pour une interception durable.

Tentative 3 : Magisk (Envisagée) Une solution technique consisterait à utiliser **Magisk** et un module pour monter le certificat en "overlay" au démarrage (contournant le problème du Read-Only). Cependant, la complexité de l'installation de Magisk sur un émulateur AVD dans l'environnement restreint des salles de TP n'a pas permis d'aboutir à une solution stable.

Conclusion de l'approche logicielle

Malgré l'exploration de QEMU et Android Studio, les sécurités modernes d'Android (en particulier le verrouillage de la partition système en Read-Only et l'absence de bibliothèques ARM sur les images x86) rendent l'approche logicielle extrêmement complexe à mettre en œuvre dans le temps imparti.

Nous n'avons donc pas de VM Android fonctionnelle pour l'interception. Nous pivotons vers l'approche matérielle (Hardware Hacking) pour extraire les informations directement depuis l'électronique de l'alarme.

2. Approche Matérielle (Hardware Hacking)

(Suite du TP : Analyse UART, lecture des trames, etc.)