Introduction

MQTT est un protocole publish/subscribe. Les clients ne communiquent jamais directement entre eux : ils publient des messages sur des topics (cam/frontdoor/events), et un broker transmet chaque message à ceux qui y sont abonnés à ce moment-là. Il a été conçu pour des appareils aux ressources limitées et des liaisons peu fiables, ce qui explique qu’on le retrouve partout dans l’IoT. Un capteur sur batterie peut se réveiller, effectuer une mesure, publier sa donnée et se rendormir. Si le message porte le flag retained, le broker conserve la dernière valeur de ce topic et la livre à chaque nouvel abonné dès sa connexion.

Le protocole n’impose pas d’authentification ; cela dépend de la configuration du broker. Mosquitto, le broker retenu pour ce lab, refuse par défaut les connexions distantes anonymes depuis la version 2.0 (2020) : un broker ouvert aujourd’hui relève donc d’un choix de l’administrateur. Certains articles laissent entendre que ce choix reste trop courant. Ma propre recherche Shodan, port:1883 “MQTT”, a renvoyé 298 408 hôtes le 2026-10-05. Cela ne prouve rien en soi, mais en parcourant les résultats on voit des topics $SYS exposés, ce qui laisse penser à une sécurité mal configurée. C’est une raison suffisante pour monter ce lab.

La question n’est pas de savoir si un broker ouvert laisse fuiter des informations : c’est le cas. Elle est de savoir ce que change réellement chaque correctif. Je lance la même attaque en lecture contre quatre configurations du même broker : ouvert, mot de passe avec ACL plate, ACL par identité et TLS mutuel. Pour chacune, j’observe ce que l’attaquant obtient et ce qui apparaît dans le log et sur le réseau. Je ne traite pas la façon dont les identifiants peuvent être obtenus ; ce point sort du cadre de cet article.

Le lab

Le lab complet est disponible sur FootholdLab MQTT_Lab Repo. Le README donne plus de détails sur le lab, mais j’explique ici le minimum nécessaire pour comprendre la suite de l’article.

Le lab se compose de deux VMs sur un réseau privé. L’une est le client (l’attaquant) ; la seconde est un hôte Debian exécutant Docker avec trois conteneurs : le broker Mosquitto, une webcam simulée et un troisième prévu pour de futurs tests, que nous n’utiliserons pas ici.

Les IPs sont : 192.168.183.10 -> Serveur Docker 192.168.183.101 -> Le client Docker dispose d’un réseau interne pour le lab : 172.18.0.0/16 Remarque importante : Dans les résultats, Mosquitto peut apparaître avec deux IPs selon la source de l’information. La ligne de commande n’affiche que l’IP du serveur Docker ; les captures réseau prises sur le serveur Docker affichent les IPs internes de Docker.

La mise en place est similaire pour toutes les configurations testées, mais certains changements sont nécessaires à mesure que l’on ajoute de la sécurité. Tout est expliqué dans le dépôt Git ; dans cet article, je me concentre sur les résultats.

Tests du lab

Nous allons passer en revue quatre scénarios. Tous les détails sont dans le dépôt GitHub, mais je donne ici le minimum nécessaire pour comprendre chacun d’eux.

Sans mot de passe

Mosquitto permet de s’abonner à tous les topics en s’abonnant à “#”. MQTT traite # comme un wildcard : on indique donc au broker que l’on veut tout recevoir. Les topics qui commencent par $ sont spéciaux et ne sont pas inclus.

Commande mosquitto_sub -h 192.168.183.10 -t '#' -v -F 'ret=%r %t %p'

Sortie :

ret=1 cam/frontdoor/config {"name": "Front Door", "model": "LabCam 1000", "stream_url": "rtsp://admin:lab-fake-cam-pass@192.168.183.50:554/Streaming/Channels/101"}
ret=1 cam/frontdoor/status online
ret=0 cam/frontdoor/events {"event": "motion", "ts": 1791557788}
ret=0 cam/frontdoor/events {"event": "idle", "ts": 1791557793}

Comme prévu, on peut s’abonner sans mot de passe. Les deux premiers messages sont retained (ret=1) ; les autres sont des messages en direct. En principe, on ne devrait pas trouver d’URL de connexion avec des identifiants, mais on pourrait trouver des informations sur des appareils IoT utiles pour cartographier le réseau. L’essentiel, c’est que MQTT doit être sécurisé.

L’image montre le trafic de la requête.

Un autre topic auquel on peut s’abonner est $SYS/, où le broker publie ses propres messages :

mosquitto_sub -h 192.168.183.10 -t '$SYS/#' -v

Sortie :

$SYS/broker/version mosquitto version 2.1.2
$SYS/broker/uptime 1503 seconds
………………………
$SYS/broker/connections/socket/count 70
$SYS/broker/publish/messages/received 305
$SYS/broker/publish/messages/sent 464

J’ai supprimé la majeure partie de la sortie ; ce n’est qu’une longue liste de statistiques du broker. Là encore, on peut le voir dans Wireshark :

Le dernier test consiste à s’abonner au topic de la caméra : mosquitto_sub -h 192.168.183.10 -t 'cam/frontdoor/config' -v -C 1

Sortie :

cam/frontdoor/config {"name": "Front Door", "model": "LabCam 1000", "stream_url": "rtsp://admin:lab-fake-cam-pass@192.168.183.50:554/Streaming/Channels/101"}

Dans cet exemple, on récupère le message retained vu précédemment. Dans la réalité, il serait plus courant de collecter les informations envoyées par la caméra, comme des statistiques ou des alertes.

De toute évidence, ce type de configuration est désastreux et nécessite un sérieux hardening.

ACL de base

Améliorations de la configuration

Dans ce scénario, je conserve les messages retained, mais j’ajoute des utilisateurs, des mots de passe et une ACL. L’utilisateur svc_cam est destiné à la webcam (notre fausse caméra), et svc_health au health check. Ici, Docker utilise cet utilisateur pour vérifier l’état du conteneur.

# Camera service: owns its own subtree.
user svc_cam
topic readwrite cam/frontdoor/#

# Monitoring service meant to read health only
# misconfigured for the purpose of the test.
user svc_health
topic read cam/#
topic read $SYS/#
# Home Assistant user
# Also over-broad on cam (read cam/#) in this scenario.
user svc_ha
topic readwrite homeassistant/#
topic readwrite home/lab/#
topic read cam/#

J’ai ajouté un utilisateur svc_ha pour Home Assistant, une application open source de domotique. Le rôle typique de Mosquitto ici est d’échanger des messages entre Home Assistant et les appareils ou capteurs. Par exemple, un thermomètre sur batterie se réveille et envoie un message avec la température. Home Assistant est abonné au topic, le broker lui transmet donc le message dès qu’il arrive.

Résultats du lab

On commence par la même commande que dans le premier lab :

mosquitto_sub -h 192.168.183.10 -t '#' -v -d

Sortie :

Client null sending CONNECT
Client null received CONNACK (5)
Connection error: Connection Refused: not authorised.
Client null sending DISCONNECT

Les nouveaux paramètres fonctionnent et la connexion anonyme n’est plus possible. Voici ce qu’affiche le log de Mosquitto (mosquitto.log) :

2026-10-09T16:04:55: New connection from 192.168.183.101:32800 on port 1883.

2026-10-09T16:04:55: Sending CONNACK to auto-0CEEF93F-3896-B18A-DEED-2763476058CB (0, 5)

2026-10-09T16:04:55: Client auto-0CEEF93F-3896-B18A-DEED-2763476058CB [192.168.183.101:32800] disconnected: not authorised.

Les lignes correspondent à la connexion, au refus et à la déconnexion.

Le refus correspond au 5 de (0, 5), qui est le return code du trafic réseau. Même si le paquet ressemble à une acceptation (Connect Ack), c’est le return code qui porte le refus.

Vérifions ensuite l’accès à quelque chose que l’ACL autorise :

mosquitto_sub -h 192.168.183.10 -u svc_health -P 'S3cret-health' -t 'cam/frontdoor/config' -v -C 1

Sortie :

cam/frontdoor/config {"name": "Front Door", "model": "LabCam 1000", "stream_url": "rtsp://admin:lab-fake-cam-pass@192.168.183.50:554/Streaming/Channels/101"}

L’ACL l’autorise, mais logiquement un service de santé ne devrait pas accéder à la configuration de la webcam. J’ai introduit cette erreur de configuration pour montrer à quel point il est important de bien définir les filtres.

Ce que montre le réseau :

On voit une connexion réussie, l’abonnement, le message publié et, enfin, la déconnexion du client.

Passons à une configuration d’ACL plus restrictive.

ACL stricte

On filtre maintenant le topic de la caméra par client ID, ce qui le restreint à un client précis. On retire aussi à svc_health l’accès à la caméra. svc_ha joue le rôle du serveur qui aurait normalement besoin d’accéder à la caméra pour remonter les informations utiles vers un dashboard. Cette configuration présente un problème de sécurité que je n’ai pas exploré : %c représente le client ID, mais rien ne le vérifie. N’importe qui pourrait s’identifier comme frontdoor et accéder aux données. Cela pourrait faire l’objet d’un futur lab.

# Any client may only touch the camera subtree matching its own client-id.
# camera connects with client-id "frontdoor" -> cam/frontdoor/#
pattern readwrite cam/%c/#

# Monitoring service: health topic and broker stats only. No camera access.
user svc_health
topic read health/#
topic read $SYS/#
# Home Assistant: own namespace. Reads only camera EVENTS, never config.
user svc_ha
topic readwrite homeassistant/#
topic readwrite home/lab/#
topic read cam/+/events

À ce stade, on désactive aussi les messages retained. La seule raison est d’observer la différence : dans un environnement où les appareils se connectent à tout moment pour lire quelque chose partagé auparavant, le désactiver n’aurait pas de sens, mais voyons ce que cela implique. On le fait avec la ligne suivante dans mosquitto.conf : retain_available false Il faut aussi modifier notre fausse webcam pour qu’elle envoie ses messages avec retain à 0 ; sinon, le broker les rejette. Les deux versions du script sont sur GitHub.

Tests

On essaie de s’abonner au topic des événements en tant que Home Assistant. Le ‘+’ représente un niveau du topic. Cette commande devrait fonctionner, car on l’autorise dans la dernière ligne de l’ACL. Sinon, l’accès serait limité aux topics de son client ID. mosquitto_sub -h 192.168.183.10 -u svc_ha -P 'S3cret-ha' -t 'cam/+/events' -v -W 8

Sortie :

cam/frontdoor/events {"event": "motion", "ts": 1791543904}
cam/frontdoor/events {"event": "idle", "ts": 1791543909}
Timed out

On voit le paquet de connexion, la demande d’abonnement, l’ACK du broker et la façon dont le broker transmet les messages provenant de la caméra.

Cela se termine par un timeout, que l’on a fixé avec le flag -W.

Essayons de nous abonner à quelque chose que nous n’avons pas le droit de lire, avec des identifiants valides.

mosquitto_sub -h 192.168.183.10 -u svc_health -P 'S3cret-health' -t 'cam/#' -v -W 8

La commande ne renvoie rien : ni données ni erreurs.

Le réseau montre ce qui se passe : le client s’abonne et le broker accepte, mais aucun message n’est envoyé. Le broker applique l’ACL au moment de livrer les messages aux abonnés, pas au moment d’accepter l’abonnement.

La commande suivante publie un message en se faisant passer pour la caméra, mais avec le flag retain activé (paramètre -r). Comme on a désactivé cette option dans le broker, il ne devrait pas l’accepter.

mosquitto_pub -h 192.168.183.10 -u svc_cam -P 'S3cret-cam' -i frontdoor -t cam/frontdoor/config -m x -r -q 1 -d

Sortie :

Client frontdoor sending CONNECT
Client frontdoor received CONNACK (0)
Client frontdoor sending PUBLISH (d0, q1, r1, m1, 'cam/frontdoor/config', ... (1 bytes))
Error: The connection was lost.

Le broker accepte la connexion, mais le client renvoie une erreur. On sait pourquoi, mais regardons le réseau :

Le client est connecté, mais le broker ferme la connexion et le client signale une erreur.

Un dernier test pour voir si l’on peut lire les secrets comme dans les tests précédents :

mosquitto_sub -h 192.168.183.10 -u svc_health -P 'S3cret-health' -t 'cam/frontdoor/config' -v -C 1

Cette fois, on ne voit rien. Le message recherché n’est pas stocké, puisqu’on a supprimé l’option retain. Mais même s’il l’était, cet utilisateur n’y aurait pas accès à cause de l’ACL.

Dans le trafic réseau, on voit, comme dans le deuxième test, que l’on peut s’abonner mais qu’aucun message n’est récupéré. Avec cette configuration d’ACL, les secrets sont mieux protégés.

Configuration TLS

Ce scénario nécessite plusieurs changements, décrits plus en détail sur GitHub. En résumé :

  • Créer les certificats. Un script est disponible.
  • Mettre à jour la configuration pour activer TLS, ajouter le port 8883 et indiquer à Mosquitto le chemin des certificats.
  • Modifier le code de notre fausse webcam pour qu’elle utilise les certificats et puisse envoyer des messages.

À noter : on garde le port 1883 exposé dans Docker pour pouvoir tester les scénarios précédents, mais dans un environnement réel il devrait être fermé. Essayons les commandes suivantes des labs précédents :


mosquitto_sub -h 192.168.183.10 -u svc_health -P 'S3cret-health' -t 'cam/#' -v -W 5

mosquitto_sub -h 192.168.183.10 -u svc_cam -P 'S3cret-cam' -i frontdoor -t 'cam/frontdoor/#' -v -W 5

mosquitto_pub -h 192.168.183.10 -u svc_cam -P 'S3cret-cam' -i frontdoor -t cam/frontdoor/config -m 'x' -r

mosquitto_sub -h 192.168.183.10 -u svc_health -P 'S3cret-health' -t 'cam/frontdoor/config' -v -C 1

La réponse est exactement la même pour les quatre :

Error: Connection refused

C’est normal, puisque le broker est configuré en TLS uniquement. Dans le trafic, le client envoie un SYN et le broker ferme la connexion avec RST, ACK.

Voyons maintenant ce qui se passe avec une requête valide :

mosquitto_sub -h 192.168.183.10 -p 8883 --cafile certs/ca.crt --cert certs/svc_ha.crt --key certs/svc_ha.key -t 'cam/+/events' -v -W 8

Sortie :

cam/frontdoor/events {"event": "idle", "ts": 1791576033}
cam/frontdoor/events {"event": "idle", "ts": 1791576038}
Timed out

Ici, on reçoit les messages du topic des événements. Le plus intéressant est le trafic : on voit le three-way handshake TCP se terminer, puis le handshake TLS qui établit la connexion chiffrée. Viennent ensuite les paquets « Application Data », qui transportent le trafic MQTT que l’on ne peut plus lire. Dans ce scénario, l’identité est liée au certificat, qui peut être configuré pour améliorer la gestion des identités. Avec cette configuration, on réduit fortement les risques.

Conclusion

En analysant le comportement de Mosquitto avec différentes configurations, on peut identifier certaines faiblesses qu’un attaquant pourrait exploiter. La recette pour maximiser la sécurité est connue : une bonne configuration, du chiffrement et des identifiants protégés. Ce protocole est souvent utilisé dans des installations domotiques qui peuvent compter un grand nombre de capteurs, lampes, interrupteurs, caméras et tout ce qui se pilote à distance. Compromettre n’importe lequel d’entre eux peut donner accès au broker. Chaque paramètre ferme une porte et peut en ouvrir une autre. La sécurité, ce n’est pas la configuration la plus stricte, mais la bonne combinaison pour le rôle de votre broker.

Si vous êtes arrivé jusqu’ici, merci de votre lecture. N’hésitez pas à partager vos commentaires, critiques ou recommandations.

:wq