Auteur/autrice : TheCodM

L’Inversion de Dépendance (IoD) est un concept fondamental en développement qui contribue à la flexibilité et à la modularité du code. C’est l’un des cinq principes SOLID, qui guident les développeurs vers une architecture plus compréhensible, flexible et maintenable. Pour résumer ce principe : les modules de haut niveau ne doivent pas dépendre des modules de bas niveau, mais tous deux doivent dépendre d’abstractions. Mais, je comprends parfaitement que cela ne soit pas très clair… Alors détaillons un peu !

Qu’est-ce que l’Inversion des Dépendances ?

L’IoD, souvent confondue avec l’injection de dépendances, alors que c’est en réalité un principe plus large. Elle se résume en deux règles majeures :

Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau. Cela signifie que les fonctionnalités majeures dans une application ne doivent pas être influencées par les détails de leur mise en œuvre.

Les abstractions ne doivent pas dépendre des détails; les détails doivent dépendre des abstractions. Cela met en avant la nécessité de définir des interfaces ou des classes abstraites qui dictent ce qu’une fonction ou un module fait, sans s’encombrer de la manière dont les tâches sont exécutées.

Exemples d’Implémentation en PHP avec Symfony

Exemple 1 : Notification System
Dans un système de notification, plutôt que de coder directement contre une classe de notification par e-mail, on définit une interface NotificationInterface avec une méthode send(). Les différentes implémentations de cette interface pourraient inclure EmailNotification, SMSNotification, etc. Ceci permet au code client de rester le même, même si le mécanisme de notification change.

interface NotificationInterface {
    public function send(string $to, string $message): void;
}

class EmailNotification implements NotificationInterface {
    public function send(string $to, string $message): void {
        // Code pour envoyer un email
        mail($to, "Notification", $message);
    }
}

class SmsNotification implements NotificationInterface {
    public function send(string $to, string $message): void {
        // Code pour envoyer un SMS
        // Supposons une fonction sendSms disponible
        sendSms($to, $message);
    }
}

class NotificationService {
    private $notifier;

    public function __construct(NotificationInterface $notifier) {
        $this->notifier = $notifier;
    }

    public function notify(string $to, string $message) {
        $this->notifier->send($to, $message);
    }
}

Exemple 2 : Système de Gestion des Utilisateurs
Lors de l’enregistrement d’un nouvel utilisateur, au lieu de créer une dépendance directe avec une classe de gestion des données utilisateur, utilisez une interface UserRepository. Cela vous permet de changer les méthodes de stockage (base de données, stockage en ligne, etc.) sans modifier le reste de votre code.

interface UserRepositoryInterface {
    public function save(User $user);
}

class MySqlUserRepository implements UserRepositoryInterface {
    public function save(User $user) {
        // Code pour sauvegarder l'utilisateur dans MySQL
    }
}

class UserController {
    private $userRepository;

    public function __construct(UserRepositoryInterface $userRepository) {
        $this->userRepository = $userRepository;
    }

    public function registerUser(string $username, string $password) {
        $user = new User($username, $password);
        $this->userRepository->save($user);
    }
}

Avantages et Inconvénients

Avantages

• Flexibilité : Les modifications ou extensions du système peuvent être réalisées sans affecter les autres parties de l’architecture.
• Facilité de test : Les composants peuvent être testés indépendamment en utilisant des mock objects.
• Réduction du couplage : Le système devient moins dépendant des implémentations spécifiques.

Inconvénients

• Complexité accrue : L’utilisation d’abstraction quand il n’y a qu’un seul type d’implémentation pour le projet (les notifications ne sont que des e-mails pour reprendre l’exemple précédent) va introduire une complexité supplémentaire inutile (over-architecture)
• Sur-abstraction : Un excès d’abstractions peut rendre moins lisible les interactions entre les différentes parties de l’application.

Considérations Connexes

En plus des avantages et des défis directement liés à l’IoD, il est essentiel de prendre en compte d’autres aspects qui peuvent influencer son application efficace dans les projets de développement logiciel.

Choix entre Abstract et Interface

Le choix entre utiliser une classe abstraite et une interface est crucial dans l’implémentation de l’IoD :

Abstract : Une classe abstraite permet de définir certaines méthodes qui peuvent être directement implémentées, et d’autres qui doivent être définies par les sous-classes. Cela est utile lorsqu’une partie du comportement doit être partagée entre plusieurs implémentations.

Interface : Une interface ne contient que des déclarations de méthodes sans implémentation. Cela force toutes les sous-classes à fournir leur propre implémentation de chaque méthode, favorisant ainsi un couplage encore plus faible et une plus grande flexibilité.

Utilisation des Traits

Les traits en PHP, par exemple, permettent de réutiliser des ensembles de méthodes dans plusieurs classes indépendantes. L’utilisation des traits doit être réfléchie car, bien qu’ils permettent de réduire la duplication de code, ils peuvent également introduire des dépendances cachées et compliquer la compréhension du flux du programme :

Avantages des traits : permettent la réutilisation du code sans forcer une relation parent-enfant, offrant une flexibilité accrue dans la conception des classes.

Inconvénients des traits : peuvent masquer les dépendances et rendre le code difficile à suivre, surtout lorsqu’ils modifient l’état interne d’une classe ou introduisent des conflits de nommage.

Pratiques de Gestion des Dépendances

L’implémentation effective de l’IoD nécessite souvent un système de gestion des dépendances sophistiqué, tel que ceux fournis par des conteneurs IoC (Inversion of Control) dans des frameworks comme Symfony. Ces outils facilitent l’instanciation et la gestion des dépendances, souvent à travers des annotations, permettant une flexibilité et un découplage maximal du code.

Implications sur les Patterns de Conception

L’adoption de l’IoD favorise également l’utilisation de divers patterns de conception :

• Factory Pattern : Permet de centraliser la création d’objets, ce qui est particulièrement utile lorsque l’objet doit être créé selon une certaine configuration ou un certain contexte.
• Strategy Pattern : Utilisé pour sélectionner l’algorithme de comportement d’un objet lors de l’exécution, ce qui est pratique pour les systèmes qui doivent être extensibles par rapport aux types de tâches qu’ils peuvent accomplir.
• Observer Pattern : Facilite la notification des changements à plusieurs classes, ce qui est souvent nécessaire dans des systèmes complexes où les actions dans une partie du système peuvent nécessiter des réactions dans d’autres parties.
• Chain of responsibility Pattern : Permet de réduire la complexité d’un processus en traitant unitairement chaque règle métier dans une classe dédiée qui interviendra ou non dans le processus selon sa propre décision.

Conclusion

Pour les développeurs, adopter l’Inversion de Dépendance, c’est utiliser un style de conception qui privilégie la flexibilité et la maintenabilité à long terme au détriment d’une légère complexité initiale accrue. Cela encourage à penser au « comment » seulement après avoir défini le « quoi », permettant ainsi de construire des applications plus robustes et évolutives. 

Selon nous, la maîtrise de ce principe est essentielle pour créer des logiciels solides et facilement extensibles.

Ceci est une courte introduction au vaste domaine qui est la gestion de la sécurité d’un projet web. Suivre les recommandations de l’OWASP (Open Web Application Security Project) est indispensable pour protéger votre application contre les vulnérabilités et les menaces potentielles.

Il y a trois thèmes à aborder pour gérer la sécurité d’un projet web :

1 – D’abord gérez la sécurité d’un projet web dans le code : 

La liste est un peu longue mais voilà les bonnes pratiques que vous devez adopter pour vous assurer que votre code est bien géré, et qu’il respecte les bases en termes de sécurité d’un projet web : 

• l’authentification : L’authentification est le processus par lequel un système vérifie l’identité d’un utilisateur. Elle repose en général sur le nom de l’utilisateur et un mot de passe. L’authentification garantit que seuls les utilisateurs autorisés peuvent accéder aux systèmes et aux données. Assurez-vous que les mots de passe sont stockés de manière sécurisée à l’aide de hachages et de salages pour protéger les informations d’identification. Vous pouvez aussi utiliser une authentification à multiples facteurs (MFA) pour exiger une méthode d’identification supplémentaire, en plus du mot de passe (par exemple, les banques demandent souvent une confirmation par mobile).

• la gestion des sessions : Les sessions sont des mécanismes qui permettent à un site web de maintenir l’état d’un utilisateur entre les différentes requêtes HTTP. Le vol de session permet à l’attaquant d’accéder aux données de l’utilisateur. Pour se protéger, vous pouvez utiliser des cookies sécurisés, la régénération de l’ID de session après l’authentification, la validation stricte des cookies de session ou encore l’utilisation de connexions sécurisées (HTTPS). 

• la protection contre les injections : L’injection SQL est une technique de piratage qui consiste à insérer du code SQL malveillant dans les saisies d’un utilisateur d’une application. Cela peut permettre à un attaquant de manipuler une base de données ou d’extraire des informations. Pour prévenir l’injection SQL, il est essentiel de valider et de filtrer les entrées utilisateur de manière appropriée. L’utilisation d’un ORM (Object-Relational Mapping) permet en général d’éviter simplement les attaques par injection SQL. 

• Protection contre les failles de sécurité d’un projet web dans les contrôles d’accès : Appliquez des règles strictes de contrôle d’accès pour garantir que seuls les utilisateurs autorisés ont accès aux ressources sensibles. Assurez-vous que les utilisateurs ne peuvent pas accéder à des parties de l’application auxquelles ils ne sont pas autorisés.

• Protection contre les failles XSS (Cross-Site Scripting) : Les failles XSS (Cross-Site Scripting) permettent à des attaquants d’injecter du code JavaScript malveillant dans des pages web consultées par d’autres utilisateurs. Pour prévenir les attaques XSS, il est essentiel de valider et de filtrer les entrées utilisateur et d’utiliser des mécanismes de sécurité tels que les en-têtes de sécurité HTTP et les bibliothèques de sécurité d’un projet web. Les mécanismes de validation et d’échappement permettent à l’application de ne pas exécuter du code JavaScript malveillant.

• Protection contre les failles CSRF (Cross-Site Request Forgery) : Ces failles permettent d’exécuter depuis un autre site une action non désirée à l’utilisateur. Par exemple, imaginez que vous visitez un site malveillant qui appelle une URL  qui permet de changer votre mot de passe depuis une image. Pour s’en prémunir, vous pouvez utiliser des jetons anti-CSRF pour vérifier l’authenticité des requêtes de l’utilisateur et empêcher ces attaques.

• Sécurité des fichiers téléchargés : Restreignez les types de fichiers autorisés à être téléchargés. Assurez-vous que les fichiers téléchargés ne peuvent pas être exécutés sur le serveur. Dans le pire des cas, vous pouvez aussi scanner ces fichiers à l’aide d’un antivirus pour détecter des logiciels malveillants et de limiter les autorisations de téléchargement pour minimiser les risques potentiels. 
  
• Chiffrement et sécurité des communications : Utilisez HTTPS pour chiffrer les communications entre le navigateur de l’utilisateur et le serveur web. Assurez-vous de stocker les données sensibles de manière sécurisée.

N’hésitez pas à vous référer aux top 10 OWASP (2021) : 

2 – Ensuite, outillez la sécurité :

Au jour le jour, des outils permettent de vous assurer la sécurité de votre application : 

• Les outils d’analyse statique : ces outils vous permettent d’analyser votre code afin de garantir une certaine cohérence, de limiter le risque de bug ainsi que d’identifier les vulnérabilités de votre code source. Voici quelques outils populaires pour l’analyse statique de code PHP :

PHP_CodeSniffer : Cet outil vérifie certaines bonnes pratiques du code PHP telles que la PSR-12. Il peut également être étendu pour inclure des règles personnalisées.

PHPStan : PHPStan est un analyseur statique avancé qui détecte les erreurs de type ainsi que les erreurs logiques dans le code PHP.

Scrutinizer : Scrutinizer est un outil d’analyse de code en ligne qui prend en charge PHP. Il fournit des rapports détaillés sur la qualité du code, les performances et les vulnérabilités.

PHPStorm : PHPStorm, un environnement de développement intégré (IDE) pour PHP, il a l’avantage de proposer des fonctionnalités d’analyse statique du code intégrées qui signalent les problèmes en temps réel pendant que vous écrivez du code.

• la gestion des dépendances : vous devez vous assurer que les dépendances de votre application (bibliothèques, frameworks, modules, etc.) sont à jour et ne contiennent pas de vulnérabilités connues.

Composer : Composer est l’outil de gestion de dépendances le plus largement utilisé en PHP. Il permet de définir, d’installer et de gérer les bibliothèques et les packages PHP, en utilisant un fichier de configuration (composer.json) pour spécifier les dépendances requises. Composer récupère automatiquement les packages depuis le référentiel Packagist et gère les dépendances de manière efficace. Il permet aussi, via sa commande `audit`, de signaler des dépendances vulnérables (qu’il faudrait donc mettre à jour ou changer).

• La gestion des logs : ces outils permettent le suivi et l’enregistrement des événements de sécurité, les erreurs et les activités de l’application. La gestion des logs est un élément clé permet de détecter les activités suspectes. 

Commencez par sélectionner un système de gestion des logs. PHP propose la fonction “error_log” pour les erreurs qui est souvent suffisante, mais vous pouvez également utiliser des bibliothèques de log PHP comme Monolog ou des outils tiers. Ecrivez ensuite dans votre code des instructions de logging aux points critiques, tels que les erreurs, les événements de sécurité, les connexions réussies/échouées, etc. Enfin, mettez en place une analyse régulière des logs et des sondes d’alertes pour détecter par exemple des tentatives d’intrusion et réagissez rapidement en cas de problèmes !

3 – Enfin, gérez la partie humaine de la sécurité : 

Il y a toute une partie humaine pour gérer la sécurité d’un projet web. 

• la sensibilisation et la formation à la sécurité : Sensibilisez l’ensemble de l’équipe de développement voire vos utilisateurs à la sécurité de votre  application. Les connaissances, le partage des bonnes pratiques sont essentielles pour détecter et prévenir les vulnérabilités.
• la gestion des incidents de sécurité : chercher à réduire un risque ne signifie pas qu’il est nul. Aussi, n’hésitez pas à préparer un plan de réponse aux incidents de sécurité pour réagir rapidement.
• la documentation : Documentez les pratiques de sécurité, les procédures et les politiques de l’application pour que toute l’équipe ait accès aux informations nécessaires.

4 – Quelques expériences horribles…

Nous avons eu l’occasion d’expérimenter quelques-uns des problèmes de sécurité (même si ce n’était pas forcément notre code). Heureusement, nous nous en sommes toujours sorti mais l’expérience est rarement agréable, quelques exemples : 

• les plus classiques :  Pages non protégées dans le back office ou bien oubli de l’annotation @Logged dans certains modules du projet… 
• Fuites de projets utilisant Git (Salut WordPress !) : Fichier .env commité avec des informations de connexion et impossible à supprimer car Git stocke l’historique … 
• Les « script kiddies », ces scripts qui scannent le web pour rechercher un site qui n’a pas été mis à jour… Et qui trouvent un de nos sites web avec une vulnérabilité connue et qui en profitent pour le défigurer, affichant des messages politiques plus que douteux. Suivez mon conseil : gardez vos dépendances de projet à jour !

Bref, n’importe quel développeur sérieux sait qu’il va être confronté à un problème de sécurité un jour ou l’autre même s’il a été très attentif. Autant s’y préparer ! 

Lisez également notre article sur la sécurité d’un projet web : 5 failles informatiques à éviter !

Pour conclure

En suivant ces bonnes pratiques et en intégrant la sécurité d’un projet web dans tout le cycle de vie de votre développement, vous devriez être en mesure de réduire considérablement les risques liés à la sécurité. N’oubliez pas qu’il est beaucoup moins coûteux de mettre en place ces bonnes pratiques au démarrage du projet qu’à la fin où il faudra gérer d’autres urgences et rattraper potentiellement plusieurs mois de travail !

PS : Si vous désirez aller plus loin, l’OWASP propose des guides et des outils spécifiques pour aider à renforcer la sécurité des applications web.