Tuta contourne IMAP pour exploiter les failles de sécurité de Nextcloud

Dans les architectures de communication d’entreprise et de stockage cloud fédéré, les frontières de confiance reposent trop souvent sur des protocoles obsolètes. Les standards historiques tels qu’IMAP (Internet Message Access Protocol) et SMTP (Simple Mail Transfer Protocol) ont vu le jour à une époque où les réseaux étaient présumés fiables et où le chiffrement n’était qu’un ajout tardif superposé via un canal TLS opportuniste. Le service de messagerie chiffrée **Tuta** (anciennement Tutanota) s’est distingué sur le plan technique en rompant radicalement avec ce paradigme hérité du passé. Plutôt que d’encapsuler un protocole structurellement perméable dans une couche TLS, Tuta a purement et simplement abandonné IMAP au profit d’une architecture propriétaire à divulgation nulle de connaissance (*zero-knowledge*), accessible exclusivement via des API dédiées.

Analyser les raisons qui ont poussé Tuta à contourner IMAP met en lumière les exigences des postures de sécurité modernes, tout particulièrement lorsqu’on les confronte aux écosystèmes cloud auto-hébergés comme Nextcloud. Si Nextcloud fournit une suite complète d’orchestration de fichiers et de collaboration souveraine, son module de messagerie s’appuie historiquement sur des connecteurs IMAP conventionnels. Cette dépendance technique introduit des vecteurs d’attaque systémiques. Dès lors que l’on fait communiquer des architectures modernes *zero-access* avec des plateformes tributaires de protocoles historiques, les disparités de conception révèlent des vulnérabilités dans la négociation de sessions, le stockage des secrets, l’encapsulation protocolaire et l’implémentation des API distantes.

Cette masterclass technique dissèque la fracture architecturale entre le moteur *zero-access* de Tuta et les protocoles applicatifs de Nextcloud. Elle détaille comment ce contournement protocolaire met en évidence les failles structurelles des infrastructures cloud privées et fournit aux ingénieurs sécurité les clés pour durcir leurs environnements souverains face aux vecteurs d’exploitation avancés.

—

1. Le schisme architectural : pourquoi Tuta rejette IMAP

Pour comprendre la rupture des périmètres de sécurité au sein des environnements cloud hybrides, il convient d’analyser les choix d’ingénierie qui justifient le refus catégorique de Tuta d’intégrer IMAP.

« `
+——————————————————————-+
| MODÈLE IMAP HISTORIQUE |
| |
| [Client] [Serveur (En clair)] |
| | |
| Indexe objet, |
| expéditeur, corps, PJ. |
| Expose les métadonnées |
+——————————————————————-+

+——————————————————————-+
| MODÈLE TUTA ZERO-ACCESS |
| |
| [Client (Déchiffrement local)] [Serveur]|
| | | |
| Dérivation locale des clés Stocke des blobs |
| Argon2id + AES-256-GCM chiffrés sans index |
+——————————————————————-+
« `

Les vulnérabilités inhérentes à IMAP
Le protocole IMAP (RFC 3501) repose sur la gestion d’états côté serveur. Le serveur de messagerie maintient un index centralisé regroupant l’ensemble des messages, drapeaux, arborescences de dossiers et index de recherche. Cette conception impose des contraintes sévères :
1. **Des métadonnées exposées en clair :** Même lorsque la charge utile est chiffrée via S/MIME ou PGP, le serveur doit impérativement parser les en-têtes du message (`Subject`, `From`, `To`, `Date`, `Message-ID`) pour structurer les dossiers et exécuter les requêtes de tri.
2. **Une recherche conditionnée par le serveur :** La commande IMAP `SEARCH` s’exécute directement sur l’index local du serveur. Un chiffrement de bout en bout authentique neutralise les commandes de recherche natives d’IMAP, à moins que le serveur n’ait un accès direct aux données déchiffrées.
3. **Des états de session persistants et vulnérables :** Les sessions IMAP maintiennent des connexions TCP avec état sur de longues durées. Toute compromission d’un démon de messagerie (ex. Dovecot, Cyrus) expose directement les zones mémoire contenant les identifiants de session en clair ainsi que les tampons de messages non chiffrés.

L’alternative Tuta : architecture REST à divulgation nulle de connaissance
Tuta a délibérément exclu toute rétrocompatibilité avec les démons de messagerie standard. En lieu et place des gestionnaires IMAP, Tuta s’appuie sur un magasin d’objets interfacé par une API REST asynchrone, scellée cryptographiquement.

* **Primitives cryptographiques exécutées côté client :** Tuta déporte l’ensemble des opérations cryptographiques sur le terminal utilisateur. Le mot de passe ne quitte jamais le navigateur ou le client natif sans faire l’objet d’une dérivation de clé locale via Argon2id.
* **Indexation chiffrée :** Lorsqu’un utilisateur effectue une recherche dans sa boîte de réception Tuta, l’index est généré, chiffré et stocké intégralement dans le stockage local du client (SQLite ou IndexedDB). L’infrastructure distante de Tuta ne traite jamais la moindre requête de recherche en clair.
* **Encapsulation de clés symétriques et asymétriques :** Les courriels échangés entre utilisateurs de la plateforme sont chiffrés à l’aide de clés publiques issues de la cryptographie sur les courbes elliptiques ou de clés RSA robustes, tandis que le corps du message et les pièces jointes font l’objet d’un chiffrement symétrique AES-256-GCM.

En éliminant IMAP, Tuta neutralise d’emblée toute une taxonomie de vecteurs d’exploitation distants : injections de commandes IMAP, débordements de tampon dans les démons de messagerie historiques et fuites de métadonnées au niveau des proxys inverses assurant la terminaison TLS.

—

2. Architecture de messagerie Nextcloud et surface d’attaque

Nextcloud aborde la communication selon une philosophie opérationnelle radicalement différente. Conçu comme une suite collaborative modulaire et fédérée, Nextcloud agit comme une surcouche applicative connectée à des services réseau préexistants. Son client de messagerie par défaut (`apps/mail`) fonctionne comme un client web IMAP/SMTP développé en PHP.

Traitement des courriels sous Nextcloud
Nextcloud n’agit ni comme un agent de transfert de courrier (MTA) ni comme un agent de distribution (MDA). Son fonctionnement repose sur le cycle suivant :
1. L’utilisateur renseigne ses identifiants IMAP (hôte, port, nom d’utilisateur, mot de passe) dans l’interface de Nextcloud Mail.
2. Nextcloud chiffre ces secrets à l’aide d’une clé maîtresse côté serveur, puis les consigne dans la table de base de données `oc_mail_accounts`.
3. À chaque requête de l’utilisateur, les processus PHP ouvrent un socket sortant vers le serveur IMAP externe ou local, s’authentifient en clair ou via SASL sur TLS, récupèrent les messages au format RFC 822, les analysent au moyen de bibliothèques PHP dédiées (telles que Horde) et restituent le contenu dans l’interface web.

« `
[Navigateur Client]
│
▼ (HTTPS)
[Cœur Nextcloud (PHP-FPM)]
│
├─► Lecture/Écriture [Base de données (oc_mail_accounts)]
│ (Stocke les identifiants IMAP chiffrés symétriquement)
│
▼ (Socket IMAP/TLS)
[Serveur IMAP Cible (Dovecot/Postfix)]
« `

Failles structurelles du modèle
Ce modèle engendre des risques majeurs que Tuta élimine dès sa conception :
* **Centralisation des identifiants :** Nextcloud doit obligatoirement stocker des identifiants réversibles pour dialoguer avec le serveur IMAP amont. Si un attaquant parvient à exécuter du code à distance (RCE) ou à exploiter une inclusion de fichier local (LFI) ciblant le fichier de configuration de Nextcloud (`config.php`), il peut extraire le secret du serveur, déchiffrer la table `oc_mail_accounts` et compromettre l’intégralité des comptes IMAP synchronisés.
* **Vulnérabilités liées au parsing de courriels en PHP :** L’analyse de types MIME complexes, de pièces jointes encodées et de messages multipart imbriqués directement au sein des processus de travail PHP a historiquement généré des failles critiques : corruption de mémoire, désérialisation d’objets non fiables et injections de scripts intersites (XSS) via des charges utiles HTML insuffisamment assainies.
* **Falsification de requête côté serveur (SSRF) :** Nextcloud acceptant des configurations de serveurs IMAP arbitraires saisies par l’utilisateur, l’application peut être forcée d’initier des poignées de main TCP vers des interfaces réseau internes (ex. `127.0.0.1:25`, `169.254.169.254:80`), contournant ainsi le filtrage des pare-feux.

—

3. Analyse de la menace : contournement des contrôles IMAP pour exploiter Nextcloud

Face à des environnements où coexistent des solutions de messagerie ultra-sécurisées (comme Tuta) et des plateformes comme Nextcloud, le contournement protocolaire devient le vecteur d’attaque privilégié. Les attaquants ne s’attaquent pas frontalement aux primitives cryptographiques durcies ; ils détournent les mécanismes de transport pour viser la logique applicative.

Vecteur 1 : Exploitation du contournement de la couche applicative
Tuta rejetant IMAP, les organisations cherchant à intégrer des flux *zero-knowledge* à Nextcloud recourent fréquemment à des proxys intermédiaires, des mécanismes de synchronisation WebDAV ou des webhooks tiers.

Dès lors qu’une instance Nextcloud expose des points de terminaison conçus pour la synchronisation de données externes en partant du principe qu’elles ont déjà été assainies par un relais IMAP, un attaquant peut compromettre le système sous-jacent sans jamais interagir avec un démon de messagerie réel.

#### Exemple : Ingestion de charges utiles malveillantes via Nextcloud WebDAV
Nextcloud traite la synchronisation applicative externe via son implémentation SabreDAV. Un attaquant peut forger une charge utile sérialisée qui échappe aux filtres IMAP traditionnels et cible directement la file d’attente de traitement de fichiers de Nextcloud :

« `http
PROPFIND /remote.php/dav/files/admin/ HTTP/1.1
Host: cloud.target-domain.com
Authorization: Basic YWRtaW46cGFzc3dvcmQ=
Content-Type: application/xml; charset= »utf-8″
Depth: 1

O:16: »NextcloudMailCrypt »:2:{s:7: »keyPath »;s:19: »/dev/urandom »;s:4: »data »;s:11: »malicious »;}

« `

Lorsque l’application traite des flux entrants sans délimitation protocolaire stricte, des failles émergent. Dans ce cas de figure, court-circuiter les flux de messagerie habituels permet à des données brutes d’atteindre directement les moteurs d’analyse internes de Nextcloud.

Vecteur 2 : SSRF indépendant d’IMAP
L’application Mail de Nextcloud permet de définir librement les hôtes de messagerie. Si l’environnement applicatif ne vérifie pas rigoureusement que le service distant est bel et bien un serveur IMAP légitime, un attaquant peut soumettre des adresses IP et des ports arbitraires pour sonder l’infrastructure cloud interne.

« `
[Requête de l’attaquant]
│
▼
POST /apps/mail/api/accounts HTTP/1.1
Host: cloud.target-domain.com
Content-Type: application/json

{
« email »: « user@target.com »,
« imapUser »: « admin »,
« imapHost »: « 169.254.169.254 »,
« imapPort »: 80,
« imapSslMode »: « none »,
« transport »: « tcp »
}
« `

Si Nextcloud tente d’établir une connexion sur ce socket TCP ouvert et initie la poignée de main IMAP (`* OK …`), un attaquant ciblant des points de terminaison de métadonnées ou des microservices internes dépourvus d’authentification peut analyser la latence des réponses, déclencher des opérations via les API internes ou extraire des configurations sensibles.

L’architecture de Tuta élimine structurellement cette classe d’exploitation : ses clients communiquent exclusivement avec des points de terminaison d’API statiques, signés cryptographiquement, via des configurations TLS strictement verrouillées.

Vecteur 3 : Empoisonnement de la base locale et désérialisation
Lorsqu’un attaquant obtient un accès restreint à l’environnement hébergeant Nextcloud, il peut contourner l’ensemble des contrôles de transport de messagerie en empoisonnant directement les tables de cache de l’application :

« `sql
— Injection de métadonnées malveillantes dans le cache de messagerie Nextcloud
UPDATE oc_mail_messages
SET subject =  »
WHERE id = 1042;
« `

Dès qu’un administrateur consulte l’application Nextcloud Mail, le script JavaScript injecté s’exécute dans le contexte de sa session active. Cette élévation confère à l’attaquant le contrôle total de l’instance Nextcloud, lui permettant d’altérer les jetons de sécurité, de déployer des extensions malveillantes ou d’exfiltrer les fichiers chiffrés du système.

—

4. Comparaison architecturale : implémentations cryptographiques

La divergence fondamentale entre ces deux systèmes réside dans la gestion de leur cryptographie. Mettre en parallèle leurs caractéristiques techniques démontre comment Tuta s’affranchit des risques inhérents à Nextcloud :

| Composant architectural | Tuta | Nextcloud (avec l’application Mail) |
| :— | :— | :— |
| **Fondation protocolaire** | API REST propriétaire sur HTTPS | IMAP / SMTP standards (RFC 3501/5321) |
| **Gestion de la couche transport** | TLS direct avec épinglage de certificat sur clusters dédiés | Connexions par sockets dynamiques via `stream_socket_client` en PHP |
| **État du chiffrement** | Chiffrement de bout en bout (E2EE) Zero-Knowledge | Couche de transport uniquement (TLS opportuniste), sauf extension PGP active |
| **Mécanisme de recherche** | Base chiffrée locale côté client (Argon2id/AES) | Indexation IMAP côté serveur ou parsing des métadonnées en base de données |
| **Gestion des clés** | Clés asymétriques et symétriques dérivées côté client | Clés privées ou mots de passe IMAP stockés sur le système de fichiers ou en base |
| **Exposition des identifiants** | Aucun secret en clair stocké côté serveur | Maintien sur le serveur d’identifiants déchiffrables pour les accès distants |
| **Surface d’attaque** | Binaire client dédié ou application web isolée | Runtime PHP, Apache/Nginx, Base de données, Démon IMAP |

Chez Tuta, la sécurité est garantie mathématiquement au niveau du client. Chez Nextcloud, elle repose sur la rigueur de configuration de l’hôte, les permissions du système d’exploitation, l’environnement d’exécution PHP et les politiques de filtrage réseau sortant.

Lors de la conception d’interfaces d’échange sécurisées ou de l’optimisation d’infrastructures ouvertes, s’appuyer sur des architectures logicielles fiables demeure un impératif. Les équipes en charge de la publication technique s’appuient fréquemment sur des assistants de rédaction automatisés et moteurs de contenu pour documenter leurs systèmes à grande échelle tout en garantissant des exigences de sécurité strictes.

—

5. Analyse détaillée d’une chaîne d’exploitation : de la désynchronisation de session à la prise de contrôle

Afin d’illustrer la manière dont le contournement des protocoles standards fragilise les environnements Nextcloud, analysons un scénario d’attaque avancée exploitant des vulnérabilités de la couche applicative pour compromettre le serveur hôte.

Étape 1 : Empreinte de l’écosystème Nextcloud
L’attaquant identifie les versions précises de Nextcloud ainsi que les modules actifs (Mail, Calendrier, Stockage externe) en interrogeant les points d’accès exposés :

« `bash
curl -s -X GET https://cloud.target-domain.com/status.php | jq .
« `

Résultat obtenu :
« `json
{
« installed »: true,
« maintenance »: false,
« needsDbUpgrade »: false,
« version »: « 27.1.2.1 »,
« versionstring »: « 27.1.2 »,
« edition »: «  »,
« productname »: « Nextcloud »
}
« `

Il sonde ensuite l’accessibilité du module Mail et de ses gestionnaires internes :

« `bash
curl -s -o /dev/null -w « %{http_code} » https://cloud.target-domain.com/apps/mail/
« `

Étape 2 : Exploitation d’un contrôle d’accès défaillant dans les gestionnaires applicatifs
Sur une instance non corrigée ou cloisonnée de manière insuffisante, les contrôleurs de l’application Mail peuvent présenter des défauts de désérialisation ou des failles de contrôle d’accès lors du routage des pièces jointes vers le stockage disque.

Considérons un scénario où l’attaquant court-circuite le mécanisme d’ingestion IMAP pour transmettre une structure MIME brute directement au point de terminaison des tâches de fond (cron) de Nextcloud :

« `php
<?php
// Représentation conceptuelle du traitement d'une pièce jointe non assainie
// au sein du gestionnaire de tâches d'arrière-plan de Nextcloud
namespace OCAMailBackgroundJob;

class SyncJob {
public function run($argument) {
// Analyse non sécurisée de paramètres contournant les filtres IMAP
$account = $argument[‘account’];
$folder = $argument[‘folder’];

// Le système écrit le fichier sans vérifier les délimitations MIME
$tempFile = ‘/tmp/mail_cache_’ . md5($argument[‘messageId’]);
file_put_contents($tempFile, $argument[‘rawPayload’]);

// Inclusion non sécurisée déclenchée par l’état applicatif
include_once($tempFile);
}
}
« `

En injectant un état de message synthétique directement dans la file d’attente Redis de Nextcloud, l’attaquant force le serveur à exécuter du code PHP arbitraire sans jamais initier la moindre connexion IMAP sortante.

Étape 3 : Évasion de la détection
L’attaque s’opérant par le biais de files d’attente applicatives et de requêtes web standard plutôt que par des flux réseau IMAP externes, les systèmes de détection d’intrusion (IDS) configurés pour surveiller les anomalies sur les ports 143, 993, 25 ou 587 restent totalement aveugles.

Cette réalité technique met en exergue le fondement sécuritaire de Tuta : **éliminer la dépendance aux protocoles historiques permet de supprimer l’immense surface d’attaque qu’ils induisent par conception.**

Maintenir des environnements logiciels hermétiques répond aux mêmes exigences que l’optimisation des architectures web : l’efficacité et la sécurité dépendent de la suppression de tout élément superflu. Tout comme les ingénieurs réseau ferment les ports d’écoute inutiles, les responsables techniques recourent à des générateurs de méta-descriptions optimisés par IA et à des abstractions de métadonnées épurées pour maintenir des flux numériques fluides et sous contrôle.

—

6. Durcissement de Nextcloud face aux exploitations applicatives et protocolaires

Pour atteindre un niveau de résilience comparable à celui des plateformes *zero-knowledge* comme Tuta, les administrateurs d’instances Nextcloud doivent appliquer une stratégie de défense en profondeur englobant le système d’exploitation, le serveur web et la couche applicative.

« `
+————————————————————–+
| STACK DE DÉFENSE EN PROFONDEUR |
| |
| [ CSP conforme W3C / CORS / En-têtes de sécurité stricts ] |
| │ |
| [ Noyau Linux : AppArmor / SELinux + Isolation Systemd ] |
| │ |
| [ PHP-FPM : open_basedir + proc_open/system désactivés ] |
| │ |
| [ Cœur Nextcloud : Pare-feu sortant strict (Port 993 seul) ]|
| │ |
| [ Base de données : Chiffrement au repos, Droits isolés ] |
+————————————————————–+
« `

1. Déploiement de politiques de sécurité de contenu (CSP) strictes
Pour neutraliser les attaques XSS stockées via des en-têtes de messagerie corrompus ou des propriétés WebDAV altérées, configurez une politique de sécurité de contenu conforme aux exigences industrielles. Consultez la spécification W3C Content Security Policy Level 3 pour l’ensemble des directives applicables.

Exemple de directives à appliquer dans la configuration Nginx :

« `nginx
# En-têtes de sécurité stricts pour Nextcloud
add_header Content-Security-Policy « default-src ‘self’; script-src ‘self’ ‘nonce-$request_id’; style-src ‘self’ ‘unsafe-inline’; frame-ancestors ‘none’; form-action ‘self’; base-uri ‘none’; » always;
add_header X-Content-Type-Options « nosniff » always;
add_header X-Frame-Options « DENY » always;
add_header X-XSS-Protection « 1; mode=block » always;
add_header Referrer-Policy « no-referrer » always;
add_header Strict-Transport-Security « max-age=63072000; includeSubDomains; preload » always;
« `

2. Cloisonnement de l’environnement d’exécution PHP-FPM
Empêchez toute charge utile RCE d’interagir avec l’ensemble du système d’exploitation en limitant drastiquement le périmètre d’exécution de PHP. Modifiez le pool PHP de Nextcloud (`/etc/php/8.2/fpm/pool.d/nextcloud.conf`) :

« `ini
[nextcloud]
user = www-data
group = www-data
listen = /run/php/php8.2-fpm-nextcloud.sock

; Restreindre l’accès au système de fichiers aux seuls répertoires strictement nécessaires
php_admin_value[open_basedir] = /var/www/nextcloud:/var/nc_data:/tmp:/dev/urandom

; Désactiver l’invocation de shells système et les fonctions critiques
php_admin_value[disable_functions] = exec,passthru,shell_exec,system,proc_open,popen,curl_multi_exec,parse_ini_file,show_source

; Forcer l’isolation des sessions
php_value[session.save_handler] = redis
php_value[session.save_path] = « tcp://127.0.0.1:6379?auth=VotreMotDePasseRedisSecurise »
« `

3. Filtrage strict du trafic sortant via pare-feu Linux (iptables / nftables)
Contrez les attaques SSRF initiées depuis l’application Mail en verrouillant les connexions sortantes vers les plages d’adresses privées et les interfaces de boucle locale (loopback). Nextcloud ne doit pouvoir émettre de requêtes que vers des serveurs de messagerie expressément autorisés sur leurs ports sécurisés (ex. TCP 993 pour IMAPS) :

« `bash
#!/usr/bin/env bash
# Verrouillage du trafic réseau sortant pour le processus PHP Nextcloud

4. Activation du chiffrement de bout en bout natif sous Nextcloud
Pour bénéficier de garanties *zero-knowledge* comparables à celles offertes par Tuta, il est indispensable de s’affranchir du stockage standard en base de données et de la synchronisation IMAP classique :
* Activez le module de **chiffrement côté serveur par défaut** au niveau du cœur Nextcloud pour sécuriser les données au repos.
* Pour les bibliothèques de fichiers sensibles, déployez l’application **End-to-End Encryption (E2EE)**. Ce module garantit que les clés de chiffrement et de déchiffrement restent cantonnées aux seuls terminaux de l’utilisateur, empêchant le serveur d’accéder aux données en clair.

—

7. Implications stratégiques pour la conception de systèmes résilients

La divergence architecturale entre Tuta et Nextcloud met en lumière les principes fondamentaux de l’ingénierie logicielle contemporaine. Qu’il s’agisse de déployer des infrastructures hautement sécurisées ou de bâtir des plateformes web publiques, les arbitrages de conception initiaux déterminent directement la surface d’exposition future.

Dans le déploiement d’interfaces numériques, les architectes techniques doivent concevoir des environnements robustes tout en préservant l’agilité opérationnelle. Pour maintenir un niveau de documentation technique irréprochable sans alourdir la charge des développeurs, de nombreuses équipes intègrent la génération de contenus assistée par IA afin de produire une documentation de référence à grande échelle.

De la même manière, garantir une présentation sans faille sur les applications web exige une stricte séparation des couches techniques. La mise en œuvre de mises en page orientées conversion permet de canaliser les parcours utilisateurs de manière fiable, en isolant les formulaires de collecte, la négociation des jetons et les interactions d’interface des traitements critiques exécutés en arrière-plan.

Pour la gestion d’actualités critiques, de bulletins de sécurité ou de documentations techniques en flux continu, les équipes opérationnelles s’appuient sur des solutions d’optimisation dynamique des titres d’actualité afin d’accroître leur portée sans introduire de complexité architecturale superflue.

—

8. Implémentation pratique : script d’audit des vulnérabilités protocolaires sous Nextcloud

Le script Python ci-dessous permet d’auditer une instance Nextcloud depuis un poste d’évaluation technique afin de vérifier l’absence d’exposition des points d’accès de messagerie et de tester la robustesse face aux contournements protocolaires :

« `python
#!/usr/bin/env python3
«  » »
Script d’audit de sécurité Nextcloud
Évalue les périmètres critiques : en-têtes CSP, protections SSRF et exposition de l’API Mail.
«  » »

import requests
import sys

def audit_nextcloud(target_url):
print(f »[*] Démarrage de l’audit sur : {target_url} »)
session = requests.Session()
session.headers.update({« User-Agent »: « SecurityAuditTool/1.0 »})

if headers.get(« X-Frame-Options ») in [« DENY », « SAMEORIGIN »]:
print( » [SUCCÈS] En-tête X-Frame-Options présent. »)
else:
print( » [ÉCHEC] X-Frame-Options absent (risque de Clickjacking). »)

if « nosniff » in headers.get(« X-Content-Type-Options », «  »):
print( » [SUCCÈS] X-Content-Type-Options défini sur nosniff. »)
else:
print( » [ÉCHEC] Protection contre le MIME-sniffing désactivée. »)

except requests.exceptions.RequestException as e:
print(f »[-] Erreur de connexion : {e} »)
sys.exit(1)