Comment sécuriser Django, framework python

Comment sécuriser une application web avec le framework python Django ?

Tout le monde est maintenant conscient de l’importance de délivrer ou utiliser un service web fortement sécurisé. Il est indispensable de protéger les données stockées dans les bases de données, valeurs inestimables, et assurer la confidentialité des échanges.

L’utilisation d’un framework comme Django permet de partir sur des bonnes bases. Mais nous allons voir qu’il est nécessaire de paramétrer finalement celui-ci.

Comment sécuriser Django ?

Je vais me servir d’un exemple concret, l’application PyFreeBilling dont je suis le créateur. PyFreeBilling est une application complète de VoIP (fonctionnalités de class 4 pour les connaisseurs) permettant à un opérateur télécom ou à une entreprise de services de connecter des clients et des fournisseurs, de router les appels, d’appliquer un tarif selon le type d’appel ainsi que l’ensemble des tâches nécessaires à cette activité.

L’exemple est intéressant du point de vue de la criticité de l’application. Une solution de communications de VoIP doit-être fortement sécurisée. Les risques de fraudes, de divulgation d’informations ou de perte de services sont importants. Un serveur à peine déployée subit ses premières attaques au bout de quelques minutes ceci étant aidé par des frameworks permettant d’automatiser les attaques.

L’interface de gestion de PyFreeBilling est développée avec le framework Django.

Pourquoi sécuriser Django ?

La sécurisation de l’interface d’administration est essentielle. Elle permet de gérer a création et la suppression de comptes SIP, la modification de mots de passe, l’augmentation des limites comme le nombre d’appels simultanés ou le volume d’appels journaliers. Un système d’anti-fraude peut ainsi être facilement détourné, un compte utilisateur pirate créé et des routes créées. Un assaillant peut aussi récupérer les données des accès opérateurs ou la base clients.

Les risques

Je vais maintenant présenter les types d’attaque les plus courantes et puis montrer comment avec Django mettre en oeuvre des solutions afin de limiter le risque.
L’OWASP est une communauté spécialisée dans la sécurité des applications web. Ils proposent notamment des outils afin de tester la sécurité des applications web. Un projet va particulièrement nous intéresser : OWASP Application Security Verification Standard (ASVS) . Je vous engage notamment à lire les cheatsheets mises à disposition.
Voici le top ten des risques définis par l’OWASP (les liens conduisent à la page détaillant chaque item) :

Mise en oeuvre des contre-mesures

Maintenant que nous avons identifié les risques et nous avons une base documentaire solide sur laquelle nous appuyer, nous allons voir les contre-mesures pour sécuriser Django.

Les injections

Tout d’abord, nous allons voir les injections SQL. Django fournit un ORM qui permet de se protéger de ce risque en échappant les variables avant de soumettre la requête à la base de données. A la condition, de ne pas utiliser la fonction RawSQL permettant d’utiliser du code SQL natif. Dans ce cas, c’est au développeur de valider les variables utilisées dans la requête !
Attention : l’ORM ne dispense pas de valider les variables, c’est une bonne pratique !

L’authentification

Nous allons retrouver plusieurs sous parties.
Tout d’abord, nous allons voir comment se protéger des attaques par brute force.
Pour se protéger des attaques que subissent constamment les pages de login, les attaques par brute force, j’utilise le package django-axes . Il permet de bloquer une adresse IP après un nombre prédéfini de tentatives infructueuses. La configuration par défaut est très satisfaisante, mais je vous invite à lire la documentation de django-axes afin de tuner votre configuration selon vos souhaits, notamment si vous avez besoin de whitelister quelques adresses IP.
Toutes les tentatives sont accessibles via l’interface d’administration incluant les adresses IP, les navigateurs, les noms d’utilisateurs utilisés …
En complément, un honeypot est intégré afin de détecter les robots malveillants testant la page /admin, page identique à la vraie page de connexion ! Toute tentative est ainsi bloquée en amont. Pour cela, j’utilise le package django-admin-honeypot.
Le second point, concerne la robustesse des mots de passe. Très souvent les utilisateurs utilisent des mots de passe trop simples. Afin, de renforcer la complexité des mots de passe, Django intègre des validateurs de mots de passe, dont voici un exemple de configuration :
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
'OPTIONS': {
'min_length': 9,
}
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
Nous allons tout d’abord vérifier que le mot de passe n’est pas trop similaire avec un attribut de l’utilisateur, puis que la longueur minimum est de 9 (je suggère d’augmenter cette valeur), ensuite nous allons vérifier s’il ne fait pas partie d’une liste de mots de passe couramment utilisés et que le mot de passe n’est pas entièrement composé de chiffres. Par ailleurs, il est aussi possible d’intégrer son propre validateur en plus de ceux prédéfinis par Django.
Le stockage du mot de passe en base de données doit aussi être particulièrement surveillé.
Django ne stocke heureusement pas les mots de passe en clair dans la base de données, mais un hash de celui-ci. Nous avons la flexibilité d’utiliser les méthodes de hachage de notre choix, mais dans une liste réputée sécurisée. Par défaut, c’est l’algorithme PBKDF2 avec un hash SHA265.
PyFreeBilling utilise l’algorithme Argon2 étant réputé plus sécurisé.
Il est possible et souhaitable d’activer une double authentification (two-factor authentication). Dans PyFreeBilling, cette fonctionnalité est optionnelle, car selon le type de déploiement, la mise en oeuvre sera plus ou moins complexe. Mais je recommande très fortement la prise en considération de cette fonctionnalité qui va renforcer sensiblement l’application. Pour cela, l’application django que je recommande est django-two-factor-auth qui intègre de nombreux services. Je ne vais pas détailler ici la mise en oeuvre, un article entier serait nécessaire. Je vous encourage à lire la documentation qui est bien faite.

Exposition de données sensibles

Il est essentiel de s’assurer qu’aucune donnée sensible ne puisse être interceptée.
Tout d’abord la mise en oeuvre du protocole HTTPS afin de garder confidentielles les données échangées est indispensable.
Par défaut, Django autorise les échanges via le protocole HTTP, mais pour des raisons évidentes, l’accès à l’interface d’administration de PyFreeBilling est forcée en HTTPS.
Pour cela nous allons forcer le navigateur l’utilisation du protocole HTTPS en activant l’entête HTTP Strict Transport Security ou HSTS.
Django définit cet en-tête pour vous sur toutes les réponses HTTPS si vous définissez le réglage SECURE_HSTS_SECONDS à une valeur entière différente de zéro.
Voici les paramètres correctement configurés :
  • SECURE_HSTS_SECONDS = 15768000 # 6 mois
  • SECURE_HSTS_INCLUDE_SUBDOMAINS = True
  • SECURE_HSTS_PRELOAD = True
Définissez aussi le paramètre SECURE_SSL_REDIRECT sur True, ainsi toutes les demandes non SSL seront redirigées de manière permanente vers SSL.
Ensuite, nous allons intégrer des entêtes HTTP afin d’activer des paramètres de sécurité embarqués dans les navigateurs modernes (et oui, il faudrait bloquer les vieux navigateurs troués comme de vieux torchons).
Anti-click jacking :
Le principe est d’interdire l’affichage d’une page de notre interface d’administration dans une frame. Django possède nativement les protections, mais qu’il faut activer correctement via les variables suivantes :
Tout d’abord il faut activer le middleware « django.middleware.clickjacking.XFrameOptionsMiddleware » afin d’ajouter l’entête X-FRAME-OPTIONS à toutes les réponses.
Par défaut, la valeur de l’entête X-Frame-Options est à SAMEORIGIN, mais il est possible de forcer à DENY ce qui est fait pour l’administration de PyFreeBilling. Ainsi, on interdit au navigateur d’intégrer nos pages dans une iFrame.
Entête CSP :
Les entêtes Content Security Policy ou CSP permet de contrôler la manière dont les ressources sont inclues dans la page.
Afin de gérer ces entêtes, le package django-csp est utilisé (https://github.com/mozilla/django-csp). Il permet de paramétrer très finement nos ressources.
Tout d’abord nos devons activer le middleware « csp.middleware.CSPMiddleware » et ensuite définir les valeurs souhaitées pour les paramètres.
Le choix fait pour PyFreeBilling est de n’utiliser aucune ressources externes pour des raisons de sécurité, mais aussi afin de pouvoir fonctionner sans accès internet (c’est le cas de certains clients). Le paramétrage des entêtes CSP est ainsi simplifié. Pour comprendre en détail les différentes valeurs, je vous engage à lire les spécifications CSP puis la documentation de django-csp.
Protection XSS :
Définissez le paramètre SECURE_BROWSER_XSS_FILTER sur True afin d’activer les protections de filtrage XSS du navigateur.
Entête X-Content-Type-Options :
Enfin, il est avisé d’empêcher le navigateur de déterminer le type de fichier en ajoutant un entête X-Content-Type-Options. Pour cela Django dispose d’une variable (à False par défaut) qu’il faut passer à True : SECURE_CONTENT_TYPE_NOSNIFF (https://docs.djangoproject.com/en/2.1/ref/settings/#secure-content-type-nosniff)

XML entités externes

Je ne vais pas traiter de cette partie, n’utilisant pas ce type de fonctions dans PyFreeBilling. Si vous souhaitez l’utiliser, vous devez soit écrire le code ou utiliser une librairie. Je vous invite à lire la documentation associée et utiliser les éléments de filtrage proposés nativement par Django.
Vous pouvez apporter des éléments en commentaire du présent article pour les futurs lecteurs (je compléterais à l’occasion cette partie)

Broken accès control

Django propose de base une gestion des utilisateurs et des groupes d’utilisateurs. Des décorateurs permettent de définir l’accès à une ressource donnée avec des droits différents : lecture, modification, création … .
Il est aussi possible de définir plus finement l’accès. Un package très utilisé est django-braces.
D’autres plugins permettent de gérer plus finement par objet ou par certains attributs. Dans tous les cas, c’est de la responsabilité du développeur d’utiliser correctement ces outils et de tester les accès suivant les différents typologies d’utilisateurs.

Mauvaises configuration de sécurité

C’est l’objet de l’article de pointer sur les points d’attention lors du paramétrage d’un projet Django. Il existe des outils afin de valider que rien n’a été oublié.
Je vous en propose 2 :
FreesScan de Qualys qui va permettre de tester en profondeur votre site avec un rapport  précis. Il va tester les certificats et la configuration du serveur web. Voici la note obtenue par un déploiement de PyFreeBilling de base sous docker :
Tous les éléments ne sont pas testés, mais ça permet de valider rapidement notre déploiement.
Et l’Observatory, outil de Mozilla permettant de vérifier de nombreux points de sécurité : il valide la sécurité des en-têtes OWASP, les meilleures pratiques TLS et effectue des tests tiers à partir de SSL Labs, High-Tech Bridge, des en-têtes de sécurité, du préchargement HSTS, etc. Il est particulièrement complet et aussi très instructif.

Cross-Site Scripting (XSS)

C’est une des failles visant le navigateur des utilisateurs. Nous allons voir comment des paramètres Django vont pouvoir nous prémunir contre elles, sachant que les outils automatisées savent les détecter et les exploiter !
Nous avons déjà vu dans la section « exposition de données sensibles » en ajoutant des entêtes HTTP en ajoutant des paramètres nous protégeant de failles XSS. Nous allons voir comment nous protéger du vol de sessions.
Il s’agit de bloquer l’accès à un code javascript exécuté dans le navigateur par un assaillant au cookie de session . Pour cela, nous allons forcer l’envoi de l’entête httpOnly transmise avec le cookie.

Les sessions sont gérées par le middleware : ‘django.contrib.sessions.middleware.SessionMiddleware’, et l’activation de l’entête est faite par la variable SESSION_COOKIE_HTTPONLY (https://docs.djangoproject.com/en/2.1/ref/settings/#std:setting-SESSION_COOKIE_HTTPONLY).
Explication de la team django : ‘It’s recommended to leave the SESSION_COOKIE_HTTPONLY setting on True to prevent access to the stored data from JavaScript.’
Afin de renforcer la sécurité des cookies, nous allons modifier 2 paramètres :
Enfin, nous allons forcer l’échange de cookies uniquement via une connexion HTTPS : la configuration par défaut est à False. Pour forcer l’échange via HTTPS, il faut mettre SESSION_COOKIE_SECURE à True.
La doc de référence de Django pour les sessions : https://docs.djangoproject.com/en/2.1/topics/http/sessions/

Insecure Deserialization

Je vais faire la même remarque que pour le traitement de document XML.

Utiliser des composants incluant des vulnérabilités connues

Django étant un framework python, vous avez plusieurs outils vous permettant d’être notifié quand une dépendance est mise à jour. Mais surtout, certains outils peuvent envoyer une notification quand une dépendance utilisée contient une faille de sécurité. J’utilise PyUp pour cela. Ils annoncent surveiller 173 000 dépendances python !

Si votre projet utilise aussi du code qui n’est pas écrit en python, ce qui est souvent le cas comme du javascript, d’autres outils existent. Pour ce javascript, npmjs ou Retire.js pourront vous être très utiles. Retire.js propose même des extensions pour Chrome et Firefox !

OWASP dispose aussi d’un outil pouvant être intégré dans votre Jenkins préféré appelé OWASP Dependency Check. Il supporte actuellement les langages Java, .NET, Ruby, Node.js, Python et partiellement C++.

Insufficient Logging&Monitoring

Il est en effet essentiel de logger les erreurs mais surtout de les traiter. Django propose des outils de génération de logs poussés. Une section dédiée à la génération de logs liés à la sécurité : https://docs.djangoproject.com/en/2.1/topics/logging/#django-security.

Pour un gros projet, un outil comme Sentry qui s’intègre parfaitement avec Django est un très intéressant.

Et pour surveiller votre application Django, les packages de monitoring sont listés dans https://djangopackages.org/grids/g/monitoring/

Conclusion

Nous avons vu au cours de cette article que la sécurisation d’une application web est une tâche complexe nécessitant de bien connaître les risques. Un framework puissant comme Django, à condition de bien le maîtriser, nous facilite la tâche.

Et pour finir, je vais vous partager un dernier truc afin d’améliorer la sécurité de notre projet Django : restreindre l’accès à toutes ou certaines URL à une ou plusieurs adresses IP.

Pour cela, le package django-iprestrict est l’outil adéquate. Afin de bloquer/autoriser l’accès à partir de région ou pays, geoip2 sera utilisé. Tout d’abord, il faut activer le middleware « iprestrict.middleware.IPRestrictMiddleware ». Le paramétrage se fait ensuite dans l’interface d’administration.

Et surtout pour sortir sécuriser Django correctement, sinon tous vos efforts auront été vains, assurez-vous d’utiliser un SECRET_KEY long, aléatoire et unique !

Si vous avez des remarques ou des packages intéressants à partager afin d’améliorer la sécurité d’un projet Django, les commentaires sont à votre disposition.

 

Django : mise à jour de yawd-admin compatible avec django 1.9

Dans cet article du 27 mai 2016, je vous annonçais la reprise en main Yawd-admin, car il n’a plus été mis à jour par les mainteneurs officiels depuis mai 2014. Yawd-admin est un package django permettant d’adapter l’interface d’administration en ajoutant des fonctionnalités indispensables.

Yawd-admin en quelques mots :

yawd-admin est un site Web d’administration de django. Il étend le site d’admin de django par défaut et propose ce qui suit :

  • une interface utilisateur « bootstrap » propre
  • du code pur HTML5/CSS3
  • une interface optimisée pour les smartphones et tablettes
  • des paramètres en base de données personnalisés (options) modifiables à partir de l’interface utilisateur. ( vous pouvez utiliser tous les champs du formulaire standard de django pour ces paramètres)
  • une intégration avec google analytique pour l’affichage des statistiques dans la page d’accueil de l’interface d’admin
  • la possibilité de lister vos applications au menu de navigation
  • un nouveau design des widgets de l’admin Django

La dernière version stable, la 0.8.0 vient d’être publiée et est compatible à 100% avec django 1.9, la dernière version de django à ce jour. Je remercie au passage henriquechehad pour son travail.

La prochaine étape concerne l’intégration de Bootstrap3 (ou 4 mais cela n’a pas l’air d’avancer très vite) en remplacement du Bootstrap 2 vieillissant.

Ensuite viendra la question de la reprise officielle de la maintenance de ce package ou la réalisation d’un fork puis publication sur pypi.

Si vous voulez donner un coup de main, le repo de yawd-admin est pour le moment sur github (je vais le migrer sur bitbucket quand j’aurais pris une décision sur fork ou pas).

Django : mise à jour de yawd-admin, template pour l’admin de Django

Depuis le 4 mai 2014, Yawd-admin n’a plus été mis à jour par les mainteneurs officiels. Plusieurs forks patchent quelques bugs et apportent une relative compatibilité avec la version 1.7 de django.
J’utilise par ailleurs ce package sur quelques projets, permettant ainsi de disposer d’une interface d’adminitration pour les sites django attrayante et performante. J’ai décidé de le mettre à jour.

Pour le moment, la dernière version stable est compatible à 100% avec django 1.6 et la version de dev avec django 1.7.
Je suis en train de finaliser la 1.8. Ensuite dès que yawd-admin sera compatible avec django 1.9, je commencerai à ajouter de nouvelles fonctionnalités.

Ensuite viendra la question de la reprise officielle de la maintenance de ce package ou la réalisation d’un fork puis publication sur pypi.

Si vous voulez donner un coup de main, le repo de yawd-admin est pour le moment sur github (je vais le migrer sur bitbucket quand j’aurais pris une décision sur fork ou pas).

Il existe un certain de nombre de paquets sympas fournissant un service à peu près équivalent pour django, comme django-grappelli, django-admin-bootstrapped, django-admin-bootstrap ou django-suit parmi ceux que j’ai utilisé et que j’apprécie.

Mais j’aime bien le look de yawd-admin même si tout n’est pas parfait, je vais pouvoir corriger quelques défaults 😉

Django : comment changer le mot de passe d’un utilisateur en ligne de commande

Comment changer le mot de passe d’un utilisateur dans un framework Django en ligne de commande ?

En fait c’est assez simple. Il faut ouvrir un shell python, importer le modèle User, récupérer l’objet correspondant à votre utilisateur, modifier l’attribut « password » et sauver l’objet.

Ne pas oublier d’activer l’environnement virtuel si nécessaire.

Voici le code correspondant à la description (n’oubliez pas de changer l’attribut « username » afin qu’il corresponde à votre utilisateur et le « password » bien sûr)

# Lancement du shell
python manage.py shell

# Le prompt change !!! >>>

# Chargement du modèle User
from django.contrib.auth.models import User

# Récupération de l'objet correspondant à notre utilisateur root
u = User.objects.get(username='root')

# Changement du mot de passe
u.set_password('mon_mot_de_passe_res_complique')

# Sauvegarde
u.save()

# On quitte le shell
exit()

Manipuler les objets Django en CLI via le shell n’est pas bien compliqué, mais terriblement utile et puissant.

django-simple-invoice : installation via pip

Installer django-simple-invoice via pip.

django-simple-invoice est une application pour le célèbre framework python Django permettant de créer et générer des factures, envoyer et télécharger les factures au format pdf et de les envoyer par mail. L’application s’intègre avec n’importe quel modèle (user, company …).

Il n’était pas possible d’installer django-simple-invoice via pip (petite étourderie de ma part – désolé). C’est maintenant possible, je viens d’effectuer la correction.

django-simple-invoice est une application pour le célèbre framework python Django permettant de créer et générer des factures, envoyer et télécharger les factures au format pdf et de les envoyer par mail. L’application s’intègre avec n’importe quel modèle (user, company …).

django-simple-invoice : application des gestion de facture pour django

Introduction

Je souhaite vous faire découvrir une application pour le framework Python Django afin de gérer les factures. Il permet de créer, modifier et envoyer des factures en utilisant une table de contacts/entreprises que vous avez définie.

django-simple-invoice : adresse du repo

Vous trouverez le repo et une documentation à l’adresse bitbucket django-simple-invoice (je vais le migrer plus tard sous github pour ajouter un outil de développement continu que j’apprécie particulièrement, travis CI, mais je vous tiendrai au courant).

Pré-requis

Les pré-requis sont très simple, Python et Django (1.5 et 1.6 pour le moment). Je bosse pour valider la compatibilité 1.7.

Installation de django-simple-invoice

L’installation est simple. 3 commandes pip :

pip install django-simple-invoice
pip install django_extensions
pip install reportlab

Setup et configuration

Vous trouverez le détail de la configuration dans le fichier Readme de django-simple-invoice. Je ne vais pas le copier ici, car il est appelé à évoluer selon les évolutions.

Licence et remerciements

Il est sous licence GPL.

Je tiens à remercier une personne ayant énormément travaillé sur ce package django (en fait, il a presque tout fait, mais n’a plus le temps de le maintenir, et comme je l’utilise dans plusieurs projets, je prends sa suite), cette personne c’est Thomas.

Conclusion

Je vous invite à le découvrir, le tester et proposer des améliorations.

Mettre en place un environnement de développement Django sous Opensuse

Nous allons voir dans cet article comment mettre en oeuvre un environnement développement Django sous Opensuse. Django est un framework très puissant programmé en python.

Installation des dépendances python

Nous commençons par installer les outils indispensables, notament pip afin de pouvoir installer nos paquets dans notre environnement.

zypper install python-devel python-pip python-virtualenv

Python est installé par défaut sur les distribution Opensuse. Nous installerons les autres paquets via pip dans un environnement virtualisé dédié à notre projet.

Création de notre environnement virtuel

Il est indispensable de créer un environnement virtuel par projet, ainsi vous pourrez sur une seule machine de développement travailler avec différentes versions de django, différentes versions de votre projet et maîtriser au mieux les dépendances spécifiques et les versions spécifiques des dépendances de votre projet.

La création d’un environnement virtuel est simple :

#Création de virtualenv appelé venv -- à remplacer par le nom que vous souhaitez --
virtualenv venv --no-site-packages

#Activation du virtualenv
source venv/bin/activate

#Se positionner dans son environnement
cd venv

#Sortir ou désactivation de votre virtualenv
deactivate

Installation de django

L’installation est assez simple grâce à pip. Je vous conseille aussi d’installer django-extensions et django-debug-toolbar ainsi que south, qui sont des outils indispensables de mon point de vue.

pip install django
pip install django-extensions
pip install django-debug-toolbar

Vérifions que django fonctionne bien. Pour cela, lancer une console python :

import django
print django.get_version()

# CTRL+D pour quitter

Avec la dernière opensuse 12.3, vous devrez obtenir  » 1.5 « . Nous sommes sous python 2.7 (2.7.3 au moment de l’écriture de l’article).

Vous êtes maintenant prêt à développer votre application django sous opensuse.