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) :
- A1:2017-Injection
- A2:2017-Broken Authentication
- A3:2017-Sensitive Data Exposure
- A4:2017-XML External Entities (XXE)
- A5:2017-Broken Access Control
- A6:2017-Security Misconfiguration
- A7:2017-Cross-Site Scripting (XSS)
- A8:2017-Insecure Deserialization
- A9:2017-Using Components with Known Vulnerabilities
- A10:2017-Insufficient Logging&Monitoring
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é.
(https://docs.djangoproject.com/en/2.1/topics/auth/passwords/#auth-password-storage)
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
(https://docs.djangoproject.com/en/2.1/ref/middleware/#http-strict-transport-security)
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.
(https://docs.djangoproject.com/en/2.1/ref/clickjacking/)
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 :
- la durée de validité d'un cookie : SESSION_COOKIE_AGE (https://docs.djangoproject.com/en/2.1/ref/settings/#std:setting-SESSION_COOKIE_AGE)
- l'expiration d'un cookie lors de la fermeture du navigateur : SESSION_EXPIRE_AT_BROWSER_CLOSE = True (https://docs.djangoproject.com/en/2.1/ref/settings/#std:setting-SESSION_EXPIRE_AT_BROWSER_CLOSE)
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.
(https://docs.djangoproject.com/en/2.1/ref/settings/#std:setting-SESSION_COOKIE_SECURE)
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.
[toc]
Introduction
Tout le monde connait maintenant les MOOCs (Massive Open Online Courses). C'est un excellent moyen de pouvoir acquérir de chez soi, ou de son entreprise, le soir ou le WE (pour ceux qui travaillent) de nouvelles connaissances. Je viens de finir le MOOC "Introduction aux réseaux mobiles" dispensé sur la plateforme FUN (France Université Numérique) par Mines Télécoms. L'Institut Mines-Télécom, pour ceux qui l'ignore, est un acteur majeur public de l’enseignement supérieur, de la recherche et de l'innovation dans les domaines de l'ingénierie et du management. 8 semaines de formation intense, avec chaque semaine un devoir à rendre.
Objectifs du MOOC
Voici le teasing officiel :
"Vous connaissez GSM, 3G ou LTE ? Venez découvrir ce qui se cache derrière ces sigles et comprendre comment fonctionnent ces réseaux qui vous permettent d'accéder à l'Internet et de communiquer, que vous soyez en ville ou à la campagne. Les objectifs de ce cours sont les suivants : connaître les principes généraux communs aux réseaux cellulaires comprendre l'architecture des réseaux cellulaires et ses composantes principales : le réseau d’accès et le réseau-cœur : illustration avec GSM et LTE assimiler les principes de l'interface radio des réseaux cellulaires connaître quelques procédures radio de base connaître les évolutions prévues des réseaux LTE Format : ce cours intègre des vidéos et des quizz sur 8 semaines. Le volume horaire a consacrer à ce cours avoisine les 40h." Mon objectif était de mieux connaître le fonctionnement des réseaux mobiles, notamment ceux de la quatrième génération.
Plan du MOOC
Semaine 1
en ligne à partir du 18 février
- Introduction
- Architectures de réseaux cellulaires (Partie 1/2)
- Architectures de réseaux cellulaires (Partie 2/2)
- Services et régulation
- Devoir Semaine 1
Semaine 2
en ligne à partir du 25 février
- Le réseau téléphonique et ses évolutions
- Sécurité (Partie 1/2)
- Sécurité (Partie 2/2)
- Devoir Semaine 2
Semaine 3
en ligne à partir du 4 mars
- Gestion de la mobilité
- Établissement d'un appel
- Intégration des réseaux intégrés paquets (facultatif)
- Devoir Semaine 3
Semaine 4
en ligne à partir du 11 mars
- Introduction seconde partie
- Propagation
- Fondamentaux de communication numérique
- Devoir Semaine 4
Semaine 5
en ligne à partir du 18 mars
- Réseau cellulaire régulier
- Analyse d'un réseau cellulaire
- Etude d'un modèle théorique plus fin
- Devoir Semaine 5
Semaine 6
en ligne à partir du 25 mars
- Interface radio : Multiplexage
- Devoir Semaine 6
Semaine 7
en ligne à partir du 1er avril
- Transmission sur l'interface radio
- Devoir Semaine 7
Semaine 8
en ligne à partir du 8 avril
- Canaux de contrôle Handover
- Examen final
Remerciements
Je tiens tout particulièrement à remercier Xavier Lagrange et toute l'équipe pédagogique du département « Réseau, Sécurité et Multimédia » de Télécom Bretagne pour la qualité des enseignements et de l'immense travail fourni.
Conclusion
Il existe maintenant nombre de MOOCs d'excellente qualité et ceux présents sur la plateforme FUN (France Université Numérique) en font partie. Si on souhaite réellement acquérir les notions exposées dans les formations, il est nécessaire de réaliser des travaux personnels, soit de synthèse, soit de recherche (Les devoirs de ce MOOC vous imposent de réaliser quelques travaux personnels sous peine d'obtenir une note très très moyenne).
Suite à cette formation, je ne suis pas expert en réseau mobile (mais la formation donne envie d'aller plus loin - pourquoi pas un cours spécifique LTE), mais l'objectif est bien atteint. Je comprends maintenant le fonctionnement d'un réseau mobile, les différences techniques entre les générations de réseaux mobiles et les contraintes d'architecture d'un réseau sans fil. Je suis heureux d'avoir validé cette formation d'excellente qualité, le temps passé m'ayant permis d'acquérir de nouvelles compétences. (J'attends mon certificat avec impatience ;-) , toute labeur méritant récompense ) Pour ceux qui sont intéressés, une nouvelle session est prévue en septembre 2014.
Il a été découvert récemment une backdoor écoutant sur le port TCP/32764 sur certains routeurs des marques Cisco, Linksys et Netgear. Cette backdoor permet de faire un reset du routeur ou de prendre le contrôle complet de ce dernier. Un petit lien vers le repo github de la personne ayant mis à jour cette backdoor : https://github.com/elvanderb/TCP-32764 Comment sécuriser son routeur afin de ne plus être vulnérable? Le plus simple, est de changer le firmware par un firmware opensource comme OpenWRT. La liste des routeurs vulnérables (liste non exhaustive malheureusement) - source elvanderb :
- Cisco RVS4000 fwv 2.0.3.2 (issue 57)
- Cisco WAP4410N (issue 11)
- Cisco WRVS4400N
- Cisco WRVS4400N (issue 36)
- Diamond DSL642WLG / SerComm IP806Gx v2 TI (https://news.ycombinator.com/item?id=6998682)
- LevelOne WBR3460B (http://www.securityfocus.com/archive/101/507219/30/0/threaded)
- Linksys RVS4000 Firmware V1.3.3.5 (issue 55)
- Linksys WAG120N (issue 58)
- Linksys WAG160n v1 and v2 (@xxchinasaurxx @saltspork)
- Linksys WAG200G
- Linksys WAG320N (http://zaufanatrzeciastrona.pl/post/smieszna-tylna-furtka-w-ruterach-linksysa-i-prawdopodobnie-netgeara/)
- Linksys WAG54G2 (@_xistence)
- Linksys WAG54GS (@henkka7)
- Linksys WRT350N v2 fw 2.00.19 (issue 39)
- Linksys WRT300N fw 2.00.17 (issue 34)
- Netgear DG834[∅, GB, N, PN, GT] version < 5 (issue 19 & issue 25 & issue 62 & jd & Burn2 Dev)
- Netgear DGN1000 (don't know if there is a difference with the others N150 ones... issue 27)
- Netgear DGN1000[B] N150 (issue 3)
- Netgear DGN2000B (issue 26)
- Netgear DGN3500 (issue 13)
- Netgear DGND3300 (issue 56)
- Netgear DGND3300Bv2 fwv 2.1.00.53_1.00.53GR (issue 59)
- Netgear DM111Pv2 (@eguaj)
- Netgear JNR3210
Avec les récentes histoires de backdoor présentent dans un certains nombre d'équipements, les solutions opensource deviennent une des solutions les plus sures, le code restant auditable. Profitez en pour regarder Pfsense ou Zeroshell. A vos Soekris !
C'est le dernier jour de l'année, l'heure terrible du bilan.