- À propos de l'Application Security en cybersécurité
- Les principales vulnérabilités et attaques contre les applications
- Les principes et les bonnes pratiques de sécurité applicative
- Les méthodes et les outils de test de sécurité des applications
- Application Security dans le cycle de développement et le DevSecOps
- Exemples pratiques de sécurité applicative avec Python
- À retenir
L'Application Security, souvent abrégée en AppSec, désigne l'ensemble des méthodes, pratiques, outils et mécanismes destinés à protéger les applications informatiques contre les vulnérabilités, les attaques, les accès non autorisés et les fuites de données. Elle concerne les applications Web, les logiciels de bureau, les applications mobiles, les API et les services Cloud. Son objectif est d'intégrer la sécurité tout au long du cycle de vie d'un logiciel, depuis sa conception jusqu'à son déploiement et sa maintenance.
1. À propos de l'Application Security en cybersécurité
Définition de l'Application Security
L'Application Security est une branche de la cybersécurité spécialisée dans la protection des applications informatiques.
Elle vise à empêcher qu'une application soit utilisée pour compromettre des données, accéder à des ressources sans autorisation ou perturber des services.
Elle comprend la conception sécurisée, la programmation défensive, les tests de sécurité, la gestion des vulnérabilités et la surveillance des applications en production.
Pourquoi la sécurité applicative est-elle importante ?
Les applications constituent des points d'accès importants aux systèmes informatiques.
Une application vulnérable peut permettre à un attaquant d'obtenir des informations confidentielles, de contourner des contrôles d'accès ou d'exécuter des opérations non autorisées.
La sécurité applicative contribue donc à protéger les utilisateurs, les données et les infrastructures.
Objectifs de l'Application Security
- Confidentialité : empêcher la divulgation non autorisée des informations.
- Intégrité : empêcher les modifications non autorisées des données.
- Disponibilité : maintenir l'accessibilité des applications et des services.
- Authentification : vérifier l'identité des utilisateurs.
- Autorisation : contrôler les opérations permises.
- Traçabilité : enregistrer les événements utiles à la sécurité.
- Résilience : réduire l'impact des incidents et faciliter la restauration.
Les applications concernées
L'Application Security concerne plusieurs catégories de logiciels :
- Applications Web : sites dynamiques, plateformes e-learning et applications métiers.
- Applications mobiles : logiciels Android et iOS.
- Applications de bureau : logiciels Windows, Linux et macOS.
- API : interfaces permettant la communication entre applications.
- Applications Cloud : services hébergés sur des infrastructures distantes.
- Applications IoT : logiciels associés aux objets connectés.
- Microservices : composants logiciels communiquant au moyen d'interfaces.
Exemple simple
Supposons qu'une application Web permette aux utilisateurs de consulter leurs documents personnels.
Si elle vérifie uniquement qu'un utilisateur est connecté, sans contrôler qu'il possède le droit de consulter le document demandé, un utilisateur pourrait accéder à des documents appartenant à d'autres personnes.
Il s'agit d'une faiblesse de contrôle d'accès.
Application Security et Network Security
La Network Security se concentre sur la protection des réseaux et des communications.
L'Application Security se concentre sur la protection du fonctionnement des logiciels, de leurs données et de leurs interfaces.
Ces deux domaines sont complémentaires.
Application Security et sécurité des données
La sécurité applicative contribue à protéger les données traitées par les logiciels grâce aux mécanismes d'authentification, d'autorisation, de validation et de chiffrement.
2. Les principales vulnérabilités et attaques contre les applications
Une vulnérabilité applicative est une faiblesse susceptible de compromettre la sécurité d'une application.
Les vulnérabilités peuvent provenir du code source, de la conception, des dépendances ou de la configuration.
Injection SQL
Une SQL Injection, ou SQLi, apparaît lorsqu'une application construit dangereusement des requêtes SQL à partir de données non fiables.
Elle peut permettre des accès ou des modifications non autorisés selon les permissions de la base de données.
La protection principale consiste à utiliser des requêtes paramétrées et à appliquer le principe du moindre privilège.
Cross-Site Scripting
Le Cross-Site Scripting, ou XSS, est une catégorie de vulnérabilités permettant l'injection de contenu actif dans certaines pages Web.
Les protections comprennent notamment l'encodage adapté au contexte de sortie, les mécanismes sûrs de rendu et une politique de sécurité du contenu appropriée.
Cross-Site Request Forgery
Le CSRF, ou Cross-Site Request Forgery, consiste à amener un navigateur authentifié à envoyer une requête non souhaitée vers une application.
Les protections peuvent comprendre des jetons anti-CSRF, les attributs appropriés des cookies et la vérification de l'origine des requêtes.
Broken Access Control
Le Broken Access Control correspond à des défaillances dans les mécanismes d'autorisation.
Une application vulnérable peut permettre à un utilisateur d'effectuer des actions ou de consulter des ressources qui ne lui sont pas destinées.
Broken Authentication
Les faiblesses d'authentification peuvent faciliter la compromission des comptes.
Elles peuvent résulter de mots de passe faibles, de sessions mal protégées ou de mécanismes d'authentification insuffisants.
Insecure Direct Object Reference
Une IDOR, ou Insecure Direct Object Reference, apparaît lorsqu'une application expose des références à des ressources sans appliquer correctement les contrôles d'autorisation.
La présence d'un identifiant de document ou d'utilisateur dans une URL n'est pas en soi une vulnérabilité. Le problème apparaît lorsque l'accès à la ressource n'est pas correctement vérifié.
Server-Side Request Forgery
Une SSRF, ou Server-Side Request Forgery, peut survenir lorsqu'une application effectue des requêtes réseau vers des destinations contrôlées par un utilisateur sans restrictions suffisantes.
Path Traversal
Une vulnérabilité Path Traversal peut permettre d'accéder à des fichiers situés en dehors des répertoires autorisés.
Elle est généralement liée à une gestion insuffisante des chemins de fichiers fournis par des utilisateurs.
Command Injection
Une Command Injection peut apparaître lorsqu'une application transmet dangereusement des données non fiables à un interpréteur de commandes.
Il est préférable d'éviter l'utilisation d'un shell lorsque cela n'est pas nécessaire et de contrôler strictement les arguments transmis.
Insecure Deserialization
Une désérialisation non sécurisée peut exposer une application à des comportements dangereux lorsqu'elle traite des données sérialisées provenant de sources non fiables.
Security Misconfiguration
Une mauvaise configuration de sécurité peut exposer des fonctionnalités d'administration, des informations sensibles ou des services inutiles.
Vulnerable Components
Les applications utilisent souvent des bibliothèques et des composants tiers.
Une dépendance contenant une vulnérabilité connue peut exposer l'application à des risques supplémentaires.
Cryptographic Failures
Les défaillances cryptographiques peuvent résulter de l'utilisation d'algorithmes inadaptés, de clés mal protégées ou d'une mauvaise gestion du chiffrement.
OWASP Top 10
L'OWASP Top 10 est une ressource de sensibilisation présentant des catégories importantes de risques de sécurité des applications Web.
Elle constitue un point de départ utile pour les développeurs et les professionnels de la sécurité, mais ne couvre pas toutes les vulnérabilités possibles.
Tableau des vulnérabilités
| Vulnérabilité | Risque principal | Protection recommandée |
|---|---|---|
| SQL Injection | Accès non autorisé aux données. | Requêtes paramétrées. |
| XSS | Injection de contenu actif. | Encodage contextuel des sorties. |
| CSRF | Actions non souhaitées. | Jetons anti-CSRF et contrôles d'origine. |
| Broken Access Control | Accès à des ressources interdites. | Autorisation côté serveur. |
| IDOR | Accès à des objets non autorisés. | Contrôle des permissions par ressource. |
| SSRF | Requêtes serveur non autorisées. | Restriction des destinations. |
| Path Traversal | Accès à des fichiers interdits. | Contrôle des chemins. |
| Command Injection | Exécution de commandes non souhaitées. | Éviter le shell et contrôler les arguments. |
| Security Misconfiguration | Exposition de services ou de données. | Configuration sécurisée. |
3. Les principes et les bonnes pratiques de sécurité applicative
La sécurité applicative repose sur plusieurs principes fondamentaux qui doivent être pris en compte dès la conception des logiciels.
Security by Design
Le principe Security by Design consiste à intégrer les exigences de sécurité dès la conception d'une application.
Il est généralement plus efficace de prévenir les vulnérabilités que de corriger tardivement des faiblesses structurelles.
Security by Default
Le principe Security by Default consiste à fournir des paramètres de sécurité adaptés dès l'installation ou le déploiement.
Principe du moindre privilège
Le Least Privilege consiste à attribuer aux utilisateurs et aux services uniquement les permissions nécessaires à leurs tâches.
Validation des entrées
Les données provenant des utilisateurs, des API et des systèmes externes doivent être considérées comme potentiellement non fiables.
La validation des entrées permet de vérifier leur format, leur type et leur conformité aux règles de l'application.
Encodage des sorties
L'encodage contextuel des sorties permet de représenter les données de manière sûre dans un contexte donné, notamment dans les pages HTML.
Authentification sécurisée
Une application doit utiliser des mécanismes d'authentification adaptés aux risques.
L'authentification multifacteur, ou MFA, peut renforcer la protection des comptes.
Gestion sécurisée des mots de passe
Les mots de passe ne doivent pas être conservés en clair.
Ils doivent être protégés au moyen de mécanismes de hachage adaptés aux mots de passe, comme Argon2id, scrypt ou bcrypt, avec des paramètres appropriés.
Gestion des sessions
Les sessions doivent être protégées contre les détournements et les utilisations non autorisées.
Les cookies de session peuvent notamment utiliser les attributs Secure, HttpOnly et SameSite selon le contexte.
Chiffrement des communications
Le protocole HTTPS protège les communications HTTP grâce à TLS.
Il contribue à préserver la confidentialité et l'intégrité des échanges entre clients et serveurs.
Gestion des secrets
Les clés API, les mots de passe de bases de données et les autres secrets ne doivent pas être intégrés directement dans le code source publié.
Ils doivent être gérés à l'aide de mécanismes adaptés à l'environnement de déploiement.
Gestion des erreurs
Les messages d'erreur destinés aux utilisateurs ne doivent pas divulguer inutilement des informations techniques sensibles.
Les détails nécessaires au diagnostic peuvent être enregistrés dans des journaux protégés.
Journalisation et surveillance
La journalisation de sécurité permet d'enregistrer les événements utiles à la détection et à l'analyse des incidents.
Les journaux doivent éviter de contenir des mots de passe ou des secrets.
Gestion des dépendances
Les bibliothèques et composants tiers doivent être régulièrement inventoriés et mis à jour.
Défense en profondeur
La défense en profondeur consiste à combiner plusieurs mécanismes de protection afin de limiter les conséquences de la défaillance d'un contrôle.
4. Les méthodes et les outils de test de sécurité des applications
Les tests de sécurité permettent d'identifier les vulnérabilités avant ou après le déploiement des applications.
SAST
Le SAST, ou Static Application Security Testing, consiste à analyser le code source ou d'autres représentations du programme sans nécessairement exécuter l'application.
DAST
Le DAST, ou Dynamic Application Security Testing, consiste à examiner le comportement d'une application en cours d'exécution.
IAST
Le IAST, ou Interactive Application Security Testing, utilise des mécanismes d'instrumentation pour analyser certains comportements d'une application pendant son exécution.
SCA
Le SCA, ou Software Composition Analysis, permet d'analyser les composants logiciels tiers et leurs dépendances.
RASP
Le RASP, ou Runtime Application Self-Protection, désigne des mécanismes intégrés ou associés à une application afin de surveiller et parfois bloquer certains comportements pendant l'exécution.
Penetration Testing
Le Pentesting consiste à réaliser des tests d'intrusion autorisés pour évaluer la sécurité d'un système ou d'une application.
Code Review
La revue de code permet d'examiner le code source afin de détecter des erreurs, des vulnérabilités et des pratiques dangereuses.
Threat Modeling
Le Threat Modeling, ou modélisation des menaces, consiste à identifier les menaces possibles et à définir des mesures de protection adaptées.
OWASP ZAP
OWASP ZAP est un outil utilisé pour analyser la sécurité des applications Web dans un cadre autorisé.
Burp Suite
Burp Suite est une plateforme utilisée pour examiner et tester la sécurité des applications Web.
Bandit
Bandit est un outil d'analyse statique destiné à identifier certaines faiblesses de sécurité dans du code Python.
Semgrep
Semgrep est un outil d'analyse de code pouvant être utilisé pour rechercher des motifs associés à des erreurs ou à des vulnérabilités.
SonarQube
SonarQube est une plateforme d'analyse de code permettant notamment d'identifier certains problèmes de qualité et de sécurité.
pip-audit
pip-audit permet de rechercher des vulnérabilités connues dans certaines dépendances Python.
OWASP ASVS
L'OWASP ASVS, ou Application Security Verification Standard, propose des exigences et des critères de vérification de la sécurité applicative.
OWASP SAMM
L'OWASP SAMM, ou Software Assurance Maturity Model, est un modèle permettant d'évaluer et d'améliorer les pratiques de sécurité dans le développement logiciel.
Tableau comparatif des méthodes
| Méthode | Principe | Objectif |
|---|---|---|
| SAST | Analyse statique du code. | Identifier certaines faiblesses de programmation. |
| DAST | Analyse d'une application en fonctionnement. | Détecter des comportements vulnérables. |
| IAST | Analyse instrumentée pendant l'exécution. | Observer certaines faiblesses applicatives. |
| SCA | Analyse des dépendances. | Identifier les composants vulnérables. |
| Code Review | Examen du code source. | Détecter des erreurs de conception ou d'implémentation. |
| Pentesting | Tests d'intrusion autorisés. | Évaluer l'exploitabilité de vulnérabilités. |
| Threat Modeling | Analyse des menaces possibles. | Définir les contrôles nécessaires. |
5. Application Security dans le cycle de développement et le DevSecOps
L'Application Security doit être intégrée tout au long du cycle de vie d'un logiciel.
Secure Software Development Lifecycle
Le SSDLC, ou Secure Software Development Lifecycle, consiste à intégrer les activités de sécurité dans les différentes étapes du développement logiciel.
Phase 1 : analyse des besoins
Les exigences de sécurité sont identifiées dès le début du projet.
Il peut s'agir de règles d'authentification, d'autorisation, de confidentialité ou de journalisation.
Phase 2 : conception sécurisée
Les architectes et développeurs définissent les mécanismes de protection adaptés.
La modélisation des menaces peut être utilisée à cette étape.
Phase 3 : développement sécurisé
Les développeurs appliquent des pratiques de programmation défensive et utilisent des composants adaptés.
Phase 4 : tests de sécurité
Les tests peuvent comprendre des analyses statiques, dynamiques, des revues de code et des contrôles des dépendances.
Phase 5 : déploiement sécurisé
Le déploiement doit tenir compte de la configuration des serveurs, des secrets, des permissions et des communications réseau.
Phase 6 : surveillance
Les applications en production doivent être surveillées afin de détecter les anomalies et les incidents.
Phase 7 : maintenance
Les vulnérabilités découvertes doivent être évaluées, priorisées et corrigées.
DevSecOps
Le DevSecOps consiste à intégrer la sécurité dans les pratiques de développement, d'exploitation et d'automatisation.
Il favorise la collaboration entre les développeurs, les équipes d'exploitation et les professionnels de la sécurité.
CI/CD et sécurité
Les chaînes CI/CD, ou Continuous Integration / Continuous Delivery, permettent d'automatiser certaines étapes de construction, de test et de déploiement.
Des contrôles de sécurité peuvent y être intégrés.
Shift Left Security
Le principe Shift Left Security consiste à réaliser les activités de sécurité le plus tôt possible dans le cycle de développement.
Shift Right Security
Le principe Shift Right Security consiste à maintenir des contrôles de sécurité pendant l'exécution et l'exploitation des applications.
Software Bill of Materials
Une SBOM, ou Software Bill of Materials, est un inventaire structuré des composants logiciels utilisés dans une application.
Elle peut faciliter la gestion des dépendances et l'analyse des vulnérabilités.
Application Security et WordPress
Pour un site WordPress, la sécurité applicative concerne notamment :
- La mise à jour du noyau WordPress.
- La mise à jour des extensions et des thèmes.
- La validation des données des formulaires.
- La vérification des permissions utilisateurs.
- La protection contre les injections SQL.
- La prévention des vulnérabilités XSS et CSRF.
- La gestion sécurisée des fichiers téléversés.
- La protection des comptes administrateurs.
Application Security et Django
Le framework Django fournit plusieurs mécanismes facilitant le développement d'applications Web sécurisées, notamment des protections CSRF, un système d'authentification et des outils de gestion des permissions.
Ces fonctionnalités doivent être correctement configurées et utilisées.
Application Security et Laravel
Le framework Laravel propose notamment des mécanismes d'authentification, de protection CSRF, de validation et de gestion des autorisations.
La sécurité finale dépend également de la conception et de l'implémentation de l'application.
6. Exemples pratiques de sécurité applicative avec Python
Python permet d'illustrer plusieurs mécanismes fondamentaux de l'Application Security.
Les exemples suivants sont pédagogiques et peuvent être exécutés localement avec Python 3. Certains mécanismes doivent être complétés par les protections d'un framework lorsqu'ils sont utilisés dans une application réelle.
Exemple 1 : valider un identifiant utilisateur
Le programme suivant vérifie qu'un identifiant possède une longueur acceptable et contient uniquement des caractères alphanumériques ou des underscores.
1 2 3 4 5 6 7 8 9 10 | def identifiant_valide(identifiant): if not 3 <= len(identifiant) <= 20: return False return all( caractere.isascii() and (caractere.isalnum() or caractere == "_") for caractere in identifiant ) print(identifiant_valide("alice_123")) print(identifiant_valide("alice!")) |
Output :
1 2 | True False |
Exemple 2 : vérifier les permissions d'un utilisateur
Le programme suivant associe des utilisateurs à des permissions et vérifie si une opération est autorisée.
1 2 3 4 5 6 7 8 9 10 11 | permissions = { "alice": ["lecture", "ecriture"], "bob": ["lecture"], "admin": ["lecture", "ecriture", "suppression"] } utilisateur = "bob" action = "suppression" if action in permissions.get(utilisateur, []): print("Opération autorisée") else: print("Accès refusé") |
Output :
1 | Accès refusé |
Exemple 3 : utiliser une requête SQL paramétrée
Le programme suivant utilise sqlite3 pour rechercher un utilisateur dans une base de données en mémoire.
La requête utilise un paramètre SQL plutôt qu'une concaténation directe de la valeur fournie.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | import sqlite3 connexion = sqlite3.connect(":memory:") curseur = connexion.cursor() curseur.execute("CREATE TABLE utilisateurs (nom TEXT)") curseur.execute( "INSERT INTO utilisateurs (nom) VALUES (?)", ("alice",) ) nom = "alice" curseur.execute( "SELECT nom FROM utilisateurs WHERE nom = ?", (nom,) ) print(curseur.fetchone()) connexion.close() |
Output :
1 | ('alice',) |
Exemple 4 : encoder du texte destiné à une page HTML
Le programme suivant utilise le module html pour encoder certains caractères spéciaux avant leur insertion dans un contexte de texte HTML.
1 2 3 4 | import html texte = "<script>alert('test')</script>" texte_securise = html.escape(texte) print(texte_securise) |
Output :
1 | <script>alert('test')</script> |
Cette méthode convient à l'encodage d'un contenu textuel HTML. Les autres contextes, comme JavaScript ou les URL, nécessitent des traitements adaptés.
Exemple 5 : générer un jeton aléatoire sécurisé
Le programme suivant utilise le module secrets pour générer un jeton aléatoire pouvant servir de base à certains mécanismes de sécurité.
1 2 3 4 | import secrets jeton = secrets.token_hex(16) print("Jeton généré :", jeton) print("Longueur :", len(jeton)) |
Output possible :
1 2 | Jeton généré : a4f0c7d91e2b83f5a6c04d7e9b1238fa Longueur : 32 |
La valeur du jeton change à chaque exécution.
Exemple 6 : comparer des secrets
Le programme suivant utilise secrets.compare_digest() pour comparer deux chaînes de caractères.
Cette fonction contribue à limiter certaines différences de temps liées à la comparaison des valeurs.
1 2 3 4 5 6 7 | import secrets jeton_attendu = "ABC123XYZ" jeton_recu = "ABC123XYZ" if secrets.compare_digest(jeton_attendu, jeton_recu): print("Jeton valide") else: print("Jeton invalide") |
Output :
1 | Jeton valide |
Exemple 7 : hacher un mot de passe avec scrypt
Le programme suivant utilise scrypt, disponible dans le module hashlib, pour dériver une empreinte à partir d'un mot de passe et d'un sel aléatoire.
Dans une application réelle, il faut également conserver les paramètres de dérivation et le sel afin de pouvoir vérifier les mots de passe ultérieurement.
1 2 3 4 5 6 7 8 9 10 11 12 13 | import hashlib import secrets mot_de_passe = "MotDePasseExemple!" sel = secrets.token_bytes(16) empreinte = hashlib.scrypt( mot_de_passe.encode("utf-8"), salt=sel, n=2**14, r=8, p=1, dklen=32 ) print("Empreinte créée :", len(empreinte), "octets") |
Output :
1 | Empreinte créée : 32 octets |
Pour les applications en production, il est recommandé d'utiliser les mécanismes de hachage de mots de passe éprouvés fournis par un framework ou une bibliothèque spécialisée, avec des paramètres adaptés.
Exemple 8 : vérifier un mot de passe avec scrypt
Le programme suivant calcule une empreinte de référence, puis vérifie un mot de passe fourni en recalculant l'empreinte avec le même sel et les mêmes paramètres.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import hashlib import secrets sel = secrets.token_bytes(16) def calculer_empreinte(mot_de_passe): return hashlib.scrypt( mot_de_passe.encode("utf-8"), salt=sel, n=2**14, r=8, p=1, dklen=32 ) empreinte_reference = calculer_empreinte("SecretExemple!") empreinte_test = calculer_empreinte("SecretExemple!") if secrets.compare_digest(empreinte_reference, empreinte_test): print("Mot de passe correct") else: print("Mot de passe incorrect") |
Output :
1 | Mot de passe correct |
Exemple 9 : contrôler l'accès à une ressource
Le programme suivant vérifie qu'un utilisateur est bien le propriétaire d'un document avant de lui autoriser l'accès.
1 2 3 4 5 6 7 8 9 10 11 | documents = { 1: {"proprietaire": "alice"}, 2: {"proprietaire": "bob"} } utilisateur = "alice" document_id = 2 document = documents.get(document_id) if document and document["proprietaire"] == utilisateur: print("Accès autorisé") else: print("Accès refusé") |
Output :
1 | Accès refusé |
Ce mécanisme illustre la prévention des vulnérabilités de type IDOR grâce à la vérification des autorisations.
Exemple 10 : vérifier un chemin de fichier
Le programme suivant utilise pathlib pour vérifier qu'un chemin demandé reste à l'intérieur d'un répertoire autorisé.
1 2 3 4 5 6 7 | from pathlib import Path dossier = Path("documents").resolve() fichier = (dossier / "../secret.txt").resolve() if fichier.is_relative_to(dossier): print("Chemin autorisé") else: print("Chemin interdit") |
Output :
1 | Chemin interdit |
La méthode is_relative_to() est disponible à partir de Python 3.9. Dans une application réelle, il faut également tenir compte des liens symboliques, des permissions et des risques liés aux changements de fichiers entre les vérifications et les accès.
Exemple 11 : limiter les tentatives de connexion
Le programme suivant simule un mécanisme de limitation du nombre de tentatives d'authentification.
1 2 3 4 5 6 7 8 9 10 | tentatives = { "alice": 2, "bob": 6 } seuil = 5 for utilisateur, nombre in tentatives.items(): if nombre >= seuil: print(utilisateur, ": accès temporairement limité") else: print(utilisateur, ": aucune limitation appliquée") |
Output :
1 2 | alice : aucune limitation appliquée bob : accès temporairement limité |
Exemple 12 : valider une adresse e-mail
Le programme suivant effectue une vérification pédagogique très simple du format d'une adresse e-mail.
Il ne remplace pas une validation complète ni une confirmation de possession de l'adresse.
1 2 3 4 5 6 7 | def email_valide(email): if email.count("@") != 1: return False nom, domaine = email.split("@") return bool(nom) and "." in domaine and not domaine.startswith(".") print(email_valide("alice@example.com")) print(email_valide("aliceexample.com")) |
Output :
1 2 | True False |
Exemple 13 : éviter l'exécution de commandes via un shell
Le programme suivant utilise le module subprocess pour exécuter une commande locale sans passer par un interpréteur de commandes.
Il fournit les arguments sous forme de liste et n'utilise pas shell=True.
1 2 3 4 5 6 7 8 | import subprocess resultat = subprocess.run( ["python", "--version"], capture_output=True, text=True, shell=False ) print((resultat.stdout or resultat.stderr).strip()) |
Output possible :
1 | Python 3.x.x |
Le numéro exact dépend de la version de Python installée. Dans une application réelle, les exécutables et les arguments autorisés doivent être contrôlés.
Exemple 14 : enregistrer un événement de sécurité
Le programme suivant utilise le module logging pour enregistrer une tentative d'accès refusée.
1 2 3 4 5 6 7 8 | import logging logging.basicConfig( filename="application_security.log", level=logging.WARNING, format="%(asctime)s - %(levelname)s - %(message)s" ) logging.warning("Tentative d'accès non autorisée détectée") print("Événement enregistré") |
Output :
1 | Événement enregistré |
Exemple 15 : mini système de contrôle de sécurité applicative
Le programme suivant combine plusieurs contrôles : authentification, autorisation et état du compte.
Il illustre la manière dont une application peut prendre une décision d'accès selon plusieurs critères.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | def verifier_acces(utilisateur, ressource): if not utilisateur["authentifie"]: return "REFUS : authentification nécessaire" if utilisateur["compte_bloque"]: return "REFUS : compte bloqué" if ressource not in utilisateur["permissions"]: return "REFUS : permission insuffisante" return "ACCES AUTORISE" utilisateur = { "authentifie": True, "compte_bloque": False, "permissions": ["lecture", "ecriture"] } print(verifier_acces(utilisateur, "lecture")) print(verifier_acces(utilisateur, "suppression")) |
Output :
1 2 | ACCES AUTORISE REFUS : permission insuffisante |
Dans une application réelle, ces contrôles doivent être exécutés côté serveur et reposer sur des informations d'identité et d'autorisation fiables.
7. À retenir
L'Application Security, ou AppSec, regroupe les méthodes et mécanismes permettant de protéger les applications contre les vulnérabilités et les attaques.
Elle concerne les applications Web, les applications mobiles, les logiciels de bureau, les API et les services Cloud.
Les vulnérabilités courantes comprennent les injections SQL, le XSS, le CSRF, les faiblesses de contrôle d'accès, les IDOR et les erreurs de configuration.
Les principes fondamentaux incluent le Security by Design, le Security by Default, le moindre privilège et la défense en profondeur.
La validation des entrées, l'encodage des sorties, les requêtes SQL paramétrées et les contrôles d'autorisation contribuent à prévenir plusieurs catégories de vulnérabilités.
Les méthodes SAST, DAST, IAST et SCA permettent d'examiner différents aspects de la sécurité applicative.
Des outils comme OWASP ZAP, Burp Suite, Bandit, Semgrep et pip-audit peuvent être utilisés pour améliorer les pratiques de sécurité.
Le DevSecOps vise à intégrer les contrôles de sécurité dans les processus de développement, de test et de déploiement.
Python permet d'illustrer plusieurs mécanismes de protection, notamment la validation, l'autorisation, la gestion des secrets et la journalisation.
Enfin, une application sécurisée nécessite une démarche continue associant conception, développement, tests, surveillance et maintenance.
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
