Les dangers de assert en Python

Il existe de nombreuses façons de trouver des bugs dans du code Python : le débogueur intégré (pdb), une bonne dose de tests unitaires, un débogueur dans un IDE comme Pycharm ou Visual Studio, des instructions try/catch, des instructions if/else, des assert statements ou encore la méthode éprouvée qui consiste à parsemer chaque recoin de votre base de code d’instructions print(), comme si cette pratique n’allait jamais passer de mode.

Les instructions assert nous aident à repérer rapidement les bugs et sont bien moins intrusives qu’une profusion d’instructions print. Mais contrairement aux instructions print, les instructions assert peuvent présenter des risques inattendus !

Cet article explique comment utiliser les assertions en toute sécurité et ce qui peut les rendre dangereuses. À la fin de votre lecture, vous saurez utiliser assert de manière optimale sans vous exposer involontairement à des problèmes de sécurité.

Utiliser les instructions assert en Python

Utiliser assert est simple ! Les instructions assert sont des instructions simples, ce qui signifie qu’elles peuvent tenir sur une seule ligne de code Python.

Voici un exemple simple d’instruction assert :

1assert expression

Dans l’instruction ci-dessus, vous vérifiez que l’expression renvoie True, comme lors d’un contrôle booléen.

Si l’expression renvoie False, une exception est déclenchée. Par exemple :

1>>> assert 'hi' == 'there'
2Traceback (most recent call last):
3  File "<stdin>", line 1, in <module>
4AssertionError

Pour faciliter l’analyse d’une trace de pile, vous pouvez spécifier un message d’assertion qui sera inclus dans l’AssertionError. Cela peut être utile dans les scénarios de débogage complexes.

1>>> assert 'hi' == 'there', 'Values do not match!'
2Traceback (most recent call last):
3  File "<stdin>", line 1, in <module>
4AssertionError: Values do not match!

La variable intégrée __debug__ de Python doit être définie sur True pour que les instructions assert soient exécutées. Si elle est définie sur False, les instructions assert ne s’exécuteront pas pendant l’exécution du programme. C’est un problème sérieux, car l’exécution de Python en mode optimisé (courante dans les environnements de production, où l’on définit l’option de ligne de commande PYTHONOPTIMIZE sur -O) définit la variable __debug__ sur False et désactive ainsi les instructions assert, ce qui peut introduire involontairement des vulnérabilités dans votre projet. Nous examinerons cela plus en détail ci-dessous.

Utilisé correctement, assert est un outil de débogage puissant. Cependant, plus son utilisation est complexe, plus le risque d’introduire des vulnérabilités de sécurité pendant le développement augmente.

En bref — Les instructions assert sont extrêmement utiles pour déboguer des applications Python, mais ne peuvent pas servir à la gestion normale des erreurs ni au contrôle du flux d’exécution, car elles peuvent :

• Interrompre l’application en déclenchant une exception, ce qui peut provoquer des interruptions de service en production.

• Provoquer des effets secondaires inattendus (pouvant inclure des vulnérabilités) dans votre application lorsque le mode de débogage est désactivé et que l’environnement d’exécution Python ignore silencieusement les instructions assert.

Utiliser assert en toute sécurité

Voyons comment utiliser les instructions d’assertion pour déboguer un programme en examinant un exemple d’application qui calcule des intérêts simples.

Commencez par installer une version stable de Python. Ouvrez ensuite un dossier et créez un fichier Python nommé safe_assert_example.py. Vous pouvez utiliser n’importe quel éditeur de code pris en charge.

Ajoutez le code suivant à safe_assert_example.py :

1def simpleInterest(p, t, r):
2print('The principal is', p)
3assert isinstance(p, int) and p > 0, "Principal must be a positive integer"
4print('The time period is', t)
5assert isinstance(t, int) and t > 0, "Time must be a positive integer"
6print('The rate of interest is', r)
7assert isinstance(r, int) and r > 0, "Rate of interest must be a positive integer"
8simpleInterest = (p * t * r) / 100
9print('The Simple Interest is', simpleInterest)
10return simpleInterest
11
12simpleInterest(3, 5, 8)

Ce programme définit la fonction simpleInterest et calcule des intérêts simples à partir du principal, de la durée et du taux.

Pour calculer correctement les intérêts, vous devez saisir des entiers positifs pour le principal, la durée et le taux. Cet exemple utilise des instructions assert pour vérifier que les valeurs p, t et r sont des entiers positifs. Le programme renvoie un message d’erreur explicite lorsqu’une valeur n’est pas un entier positif.

À vous de jouer ! Exécutez le programme à l’aide de la commande suivante :

1python safe_assert_example.py

Vous devriez obtenir le résultat ci-dessous, avec des intérêts simples de 1.2 :

1PS E:\Sample\Extra\Assert Demo> python safe_assert_example.py
2The principal is 3
3The time period is 5
4The rate of interest is 8
5The Simple Interest is 1.2

Comme vous pouvez le constater, le programme s’exécute sans problème et ne renvoie aucun message d’erreur.

Voyons maintenant ce qui se passe si vous exécutez le programme avec une entrée non valide. Remplacez la valeur de t par la chaîne "time" au lieu de 5 :

1simpleInterest(3, "time", 8)

Exécutez à nouveau le programme à l’aide de cette commande :

1python safe_assert_example.py

Cette fois, vous devriez voir l’erreur suivante :

1PS E: \Sample\Extra\Assert Demo» python safe assert example.py
2The principal is 3
3The time period is time
4Traceback (most recent call last):
5    File "E: \Sample\Extra\Assert Demo\safe assert example.py", line 12, in <module> simpleInterest(3, "time", 8)
6    File "E: \Sample\Extra\Assert Demo\safe assert example.py", line 5, in simpleInterest assert isinstance(t, int) and t > 0, "Time must be a positive integer"
7AssertionError: Time must be a positive integer

Ce résultat inclut une AssertionError. Cette exception montre que l’instruction assert fonctionne comme prévu : elle a bien détecté un argument de fonction non valide.

Dans cet exemple, l’assertion nous a aidés à déboguer le programme et en a interrompu l’exécution dès qu’elle a échoué.

Rappel : l’exécution du programme en mode optimisé (en définissant l’option de ligne de commande PYTHONOPTIMIZE sur -O) désactive silencieusement les instructions assert. Voyons maintenant l’impact de ce comportement sur l’application.

En conservant "`time=" comme valeur de t, exécutez le programme de calcul des intérêts simples en mode optimisé à l’aide de la commande suivante :

1python -O safe_assert_example.py

Le résultat est le suivant :

1PS E:\Sample\Extra\Assert Demo› python -0 safe assert example.py
2The principal is 3
3The time period is time
4The rate of interest is 8
5Traceback (most recent call last):
6    File "E:\Sample\Extra\Assert Demo\safe assert example.py", line 12, in <module> simpleInterest(3, "time", 8)
7    File "E:\Sample\Extra\Assert Demo\safe assert example.py", line 8, in simpleInterest simpleInterest = (p * t * r)/100
8TypeError: unsupported operand type(s) for /: 'str' and 'int'

Remarquez que, même si l’argument de la fonction n’est pas valide, le résultat ci-dessus ne contient pas l’AssertionError attendue. Python renvoie plutôt une TypeError, car vous avez essayé de multiplier des variables de type entier et chaîne de caractères. Cela s’explique par le fait que les instructions assert n’ont pas été exécutées et nous indique que nous devrions envisager d’autres solutions, comme :

• Ajouter des annotations de type pour détecter les appels incorrects à simpleInterest avant l’exécution du code.

• Utiliser des instructions if plutôt que des assertions pour vérifier les types à l’exécution.

Utiliser assert de façon dangereuse

Les instructions assert doivent servir uniquement aux tests et au débogage, et non aux environnements de production. Comme elles ne s’exécutent que lorsque la variable __debug__ est définie sur True, l’interpréteur Python peut les désactiver.

Comme le montre l’exemple ci-dessus, l’exécution de Python en mode optimisé avec -O empêche les instructions assert de fonctionner, car cette option définit __debug__ sur False.

Par conséquent, il est dangereux d’utiliser des instructions assert pour toute tâche devant s’exécuter en production. Par exemple, n’utilisez jamais d’assertions pour valider des jetons ou des entrées utilisateur. Ces instructions ne s’exécuteront pas en production : les jetons et les entrées utilisateur ne seront donc pas validés, ce qui risque d’introduire des vulnérabilités dans votre application.

Pour illustrer la gravité de l’utilisation d’assertions à des fins de validation en production, prenons l’exemple d’une fonction d’autorisation qui reçoit un tableau d’utilisateurs et leur permet de poursuivre en fonction de leur niveau d’accès. Le programme utilise d’abord assert pour vérifier que la liste ou le tableau n’est pas nul et qu’il s’agit bien d’une instance de liste. Ensuite, il accorde un accès complet à l’application aux utilisateurs ayant le rôle d’administrateur. Si un rôle admin figure dans la liste des utilisateurs, aucune erreur d’assertion ne sera déclenchée. En revanche, si aucun rôle admin n’y figure, une erreur sera déclenchée.

Collez ensuite ce code dans un fichier nommé unsafe_assert_example.py :

1def authorize_admin_user(user_roles):
2    assert isinstance(user_roles,list) and user_roles != [], "No user roles found"
3
4    assert 'admin' in user_roles, "No admin role found."
5    print("You have full access to the application.")
6
7authorize_admin_user(['admin','user'])

La fonction authorize_admin_user vérifie les rôles de l’utilisateur. Si celui-ci est admin, elle indique qu’il dispose d’un accès complet à l’application. En général, les rôles de l’utilisateur sont chargés depuis la base de données ; si admin en fait partie, l’utilisateur obtient un accès complet à l’application. Sinon, l’assertion échoue et déclenche une exception.

La dernière ligne du fichier appelle la fonction authorize_admin_user en lui transmettant une liste contenant deux rôles : admin et user.

1Run python unsafe_assert_example.py:
2
3$ python unsafe_assert_example.py
4You have full access to the application

Comme prévu, l’utilisateur obtient un accès complet à l’application.

Appelons la fonction avec un rôle utilisateur qui ne comprend pas le rôle admin. Modifiez la dernière ligne de code de unsafe_assert_example.py comme suit :

1authorize_admin_user(['user'])

Exécutez ensuite le programme et observez le résultat :

1$ python unsafe_assert_example.py
2Traceback (most recent call last):
3  File "C:\Projects\ContentLabEditing\python\unsafe_assert_example.py", line 6, in <module>
4    authorize_admin_user(['user'])
5  File "C:\Projects\ContentLabEditing\python\unsafe_assert_example.py", line 3, in authorize_admin_user
6    assert 'admin' in user_roles, "No admin role found."
7AssertionError: No admin role found.

Comme prévu, la fonction déclenche une AssertionError, car admin ne figure pas dans la liste des rôles.

Exécutez maintenant le même programme avec l’optimisation activée :

1python -O unsafe_assert_example.py

Le résultat correspondra à l’image ci-dessous. Bien qu’aucun rôle admin ne figure dans la liste, l’autorisation admin a été accordée, car l’assertion ne s’est pas exécutée.

1PS E:\Sample\Extra\Assert Demo> python -0 unsafe_assert_example.py
2You have full access to the application
3You have full access to the application
4PS E:\Sample\Extra\Assert Demo>

De plus, si vous modifiez l’appel de la fonction pour lui transmettre une liste d’entiers et exécutez le programme avec la même optimisation, vous constaterez encore que les instructions assert doivent servir au débogage, et non à la validation.

Remplacez l’appel de la fonction par authorize_admin_user([1,2]) et exécutez le programme à l’aide de la même commande : python -O unsafe_assert_example.py.

Le résultat du programme reste le même.

Dans notre exemple de calcul des intérêts simples, les conséquences de la non-exécution des instructions assert étaient limitées. Même si nous n’avons pas obtenu le message d’erreur attendu, le message d’erreur de Python nous a permis de comprendre le problème. Plus important encore, nous n’avons introduit aucune vulnérabilité, car nous utilisions les instructions assert à des fins de débogage sans risque.

Dans cet exemple, nous avons utilisé assert de façon dangereuse et rendu notre application Python vulnérable en accordant des droits d’administrateur à un utilisateur qui n’était pas administrateur.

Si vous souhaitez approfondir ces exemples, vous trouverez tout le code de cet article dans ce dépôt.

À faire et à ne pas faire avec assert

Assert aide les développeurs à déboguer facilement du code Python en écrivant moins de lignes. Cependant, une utilisation inappropriée peut introduire involontairement des problèmes de sécurité dans vos applications.

Désactiver les assertions en production peut avoir des conséquences désastreuses. Cette pratique peut créer diverses portes dérobées et points de rupture dans l’application, dont des acteurs malveillants peuvent tirer parti.

Les assertions doivent avant tout servir à isoler la cause première d’un bug et ne doivent jamais être utilisées pour la gestion standard des erreurs. Elles peuvent être utiles, mais il est essentiel de les réserver au débogage et aux tests, et de ne pas s’en servir pour contrôler le flux logique d’un programme ou d’une application. Utilisez-les uniquement dans des situations sans risque. Pour remplacer assert, les tests unitaires, les débogueurs, les conditions et les validateurs sont de meilleures options, plus sûres.

Maintenant que vous savez utiliser assert en toute sécurité, consultez l’aide-mémoire sur les bonnes pratiques Python pour en savoir plus sur la sécurisation de vos applications sur toutes vos plateformes et dans tous vos environnements.

Autres ressources sur le développement et la sécurité en Python

• Guide sur pickle en Python

• Bien démarrer avec le développement sécurisé en Python

• Créer un serveur WebSocket sécurisé en Python

• Conteneuriser des applications Python avec Docker

• Bonnes pratiques de sécurité en Python

Vous pouvez également essayer gratuitement notre outil de vérification du code Python en ligne pour voir comment le moteur Snyk Code analyse votre code à la recherche de problèmes de sécurité et de qualité.