Comment j'ai implémenté l'approbation d'accès dans notre projet Open Source

Il y a quelques jours, certains de mes collègues m'ont approché au sujet d'un problème avec une application Open Source appelée Makaut Buddy , une plateforme de partage de notes conçue pour notre université, visant à aider les étudiants à partager efficacement leurs notes, leurs questions d'examen passées et leurs didacticiels YouTube. .

Bien qu'ils aient développé avec succès un système de téléchargement de ressources, ils ont rencontré un défi pour garantir que seules les personnes autorisées pouvaient télécharger du contenu.

Comme le montre la démo ci-dessous, n'importe quel utilisateur peut créer une ressource après s'être inscrit. Cela posait un gros problème car nous ne pouvions pas réglementer ce que les utilisateurs téléchargent, certains pourraient même avoir téléchargé du contenu nuisible ou dérangeant.

Initialement, ils ont défini un rôle d'administrateur et accordé des privilèges administratifs à un groupe sélectionné de personnes. Cependant, à mesure que le nombre de rôles augmentait, le code devenait de plus en plus complexe et difficile à gérer.

C'est à ce moment-là que j'ai eu l'idée d'écrire cet article pour sensibiliser aux moyens efficaces de gérer les autorisations à l'aide d'un modèle de contrôle d'accès basé sur les rôles (RBAC) à l'aide d'outils d'autorisation tiers comme Permit.

En plus de mettre en œuvre RBAC, nous avons également introduit un système de demande d’approbation d’accès. Ce système garantit que tout utilisateur souhaitant télécharger du contenu doit d'abord demander l'accès, qu'un administrateur peut ensuite approuver ou refuser. Cette couche de sécurité supplémentaire nous aide à maintenir l'intégrité du contenu sur Makaut Buddy.

Dans cet article, j'ai utilisé JavaScript comme langage de programmation et Next.js comme framework. Cependant, les concepts abordés ici ne sont pas spécifiques à un langage et vous pouvez les implémenter dans votre langage de programmation préféré.

À la fin de cet article, vous saurez implémenter un modèle RBAC de base dans votre application.

Cela dit, plongeons-nous !

Qu’est-ce que l’autorisation ?

Vous vous souvenez de ces matins où on se précipitait à l'école ? L’agent de sécurité vérifiant votre pièce d’identité est un parfait exemple d’authentification. Ils vérifient votre identité en tant qu'étudiant autorisé sur le campus. Mais ce n'est que la première étape. Même après avoir été identifié, vous n’entreriez pas dans n’importe quelle salle de classe, n’est-ce pas ? C'est là qu'intervient l'autorisation.

Considérez votre horaire de cours comme votre autorisation. Il vous donne accès à des zones spécifiques (salles de classe) en fonction de votre rôle (étudiant inscrit dans cette classe). Vous ne seriez pas autorisé à accéder à la salle des professeurs ou à la section réservée de la bibliothèque – même si vous êtes étudiant (authentifié).

La différence entre l'authentification et l'autorisation revient à demander « Qui êtes-vous ? » vs "Qu'est-ce que tu es autorisé à faire?"

Pourquoi avons-nous besoin d'un modèle RBAC pour l'autorisation 🤔 ?

L'autorisation est importante dans toute organisation car elle empêche les individus d'effectuer des actions pour lesquelles ils ne sont pas autorisés. Cela garantit la sécurité de l’organisation et contribue à prévenir les pertes.

Illustrons la déclaration ci-dessus avec un exemple :

Dans une entreprise, il y a des ingénieurs seniors possédant une vaste expérience et des stagiaires qui apprennent encore les ficelles du métier. Vous pouvez imaginer le désastre que cela provoquerait si l’ingénieur principal et le stagiaire disposaient du même niveau d’autorisations. Les stagiaires qui sont encore en formation pourraient, sans le savoir, commettre des erreurs pour lesquelles l'entreprise devra payer. Dans de telles situations, le modèle de contrôle d'accès basé sur les rôles fonctionne mieux car les autorisations ne sont pas attribuées à des individus, mais à des rôles. Par exemple, seul un ingénieur senior ou un responsable technique peut supprimer des ressources, alors que tous les stagiaires peuvent uniquement afficher et gérer les ressources.

Voyons ensuite comment implémenter RBAC dans une application.

Comment implémenter RBAC dans une application :

1. Définir les rôles et les autorisations

Tout d’abord, nous devons définir des rôles et attribuer des autorisations à chaque rôle.

2. Attribuez des rôles aux utilisateurs

Nous avons besoin d'un moyen d'attribuer un rôle à chaque utilisateur de l'application. Cela se fait généralement après l’inscription de l’utilisateur.

3. Créez une API d'autorisation

Nous avons besoin d'une API dans notre backend qui prend en charge l'opération qu'un utilisateur souhaite effectuer et vérifie l'autorisation de l'utilisateur. Le schéma ci-dessous vous permettra de mieux comprendre :

Cependant, nous n’allons pas mettre en œuvre l’intégralité du modèle à partir de zéro. Au lieu de cela, nous allons utiliser un outil d'autorisation tiers appelé Permit qui rendra l'ensemble du processus d'établissement de l'autorisation très fluide et efficace pour nous, afin que vous puissiez travailler sur les fonctionnalités qui comptent vraiment.

Le diagramme ci-dessous vous montre comment nous allons exploiter Permit pour implémenter RBAC dans nos applications :

Implémentation du modèle RBAC

Dans cette section, nous passerons en revue les étapes de mise en œuvre du contrôle d'accès basé sur les rôles (RBAC) à l'aide de Permit.

Étape 1 : Créer un compte de permis et un espace de travail

Comme nous utilisons un Permit pour établir un modèle RBAC, nous devons d'abord créer un compte Permit et un espace de travail :

Étape 2 : Créer une ressource

Nous devons maintenant créer une ressource qui est l'entité à laquelle nous souhaitons contrôler l'accès dans notre application.

Par exemple, dans une application de prise de notes, la ressource serait Notes et les actions pourraient être Créer , Lire, Mettre à jour et Supprimer.

Pour créer une ressource :

1. Accédez à la section Politique.
2. Accédez à l'onglet Ressources.
3. Créez une nouvelle ressource en remplissant les détails requis.

Dans l'exemple ci-dessus, le nom de la ressource est Notes et les actions que l'utilisateur est autorisé à effectuer sont Créer, Lire, Mettre à jour et Supprimer.

Étape 3 : Définir les rôles

Après avoir créé la ressource, nous devons définir les rôles qui vont exister dans notre application.

Dans ce cas, comme l'application est une application de partage de notes pour une université, les rôles seront :

• Administrateur : peut créer et lire des ressources.
• Étudiant : peut lire des ressources.

Étape 4 : attribuer des actions aux rôles

Une fois que nous avons créé les deux rôles, nous devons maintenant attribuer les actions que chaque rôle peut effectuer à partir de notre éditeur de stratégie, comme indiqué ci-dessous :

Étape 5 : Configurer les API backend

Maintenant que votre compte Permit est configuré, vous pouvez commencer à créer les API backend pour communiquer avec Permit. Nous utiliserons le SDK Node.js fourni par Permit. Vous pouvez trouver le SDK pour votre langage de programmation préféré dans la documentation du permis.

Synchroniser les utilisateurs et attribuer un rôle par défaut

Tout d’abord, nous devons nous assurer que chaque utilisateur qui s’inscrit dans notre application est synchronisé avec le répertoire des permis et se voit attribuer le rôle par défaut d’Étudiant.

Pour ce faire, nous devons créer une API backend comme indiqué ci-dessous :

Cette API fait 2 choses :

• Initialise l'API Permit.
• Crée un nouvel utilisateur à l'aide de l'API createUser .
• Attribue un rôle par défaut à l'aide de l'API assignRole .

Vous pouvez en savoir plus sur toutes les API fournies par Permit dans la documentation sur les permis.

Obtenir le rôle de l'utilisateur

Ensuite, nous devons créer une API backend qui obtient le rôle de l'utilisateur de Permit.io et le renvoie au frontend .

L'API présentée ci-dessous permet à l'utilisateur d'utiliser permit.api.users.get(user_key)

Cette API obtient le rôle d'utilisateur avec lequel nous pouvons manipuler nos composants frontaux pour permettre uniquement aux personnes ayant des rôles spéciaux de pouvoir la voir.

Vous pouvez également consulter la fonction permit.check() pour vérifier si un utilisateur avec un certain rôle est autorisé à effectuer une opération.

Grâce à cela, nous avons implémenté avec succès un modèle RBAC utilisant Permit. Désormais, nous pouvons intégrer les routes backend avec le framework frontend ou la bibliothèque de votre choix pour terminer la configuration.

Mise en œuvre du système d'approbation d'accès :

Pour terminer notre configuration, nous avons besoin d'un composant qui permet aux utilisateurs de demander des mises à niveau de rôle :

• Un utilisateur normal sans privilèges d'administrateur peut afficher l'élément d'autorisation et demander des privilèges d'administrateur.

• Un utilisateur administrateur peut approuver ou refuser les demandes entrantes de mises à niveau de rôle émanant d'autres utilisateurs.

Étape 1 : Créer un élément de permis

Les éléments d'autorisation font partie de « Permit Share-If », une suite de composants d'interface utilisateur prédéfinis et intégrables qui facilitent le partage d'accès dans les applications. Conçus pour fournir un contrôle d’accès entièrement fonctionnel, ils simplifient et sécurisent la délégation de la gestion des autorisations à vos utilisateurs.

• Pour implémenter cela, nous devons d’abord créer un élément permit :
  • Accédez à l'onglet Éléments dans le tableau de bord des permis.
  • Cliquez sur Créer un élément dans la section Gestion des utilisateurs.

• Ensuite, nous devons remplir le formulaire avec les informations requises comme indiqué ci-dessous
  • Définissez le rôle Administrateur comme propriétaire de l’espace de travail.
  • Attribuez le rôle Étudiant à la section Visionneuse.
  • Définissez le rôle par défaut sur Étudiant.

• Enregistrez l'élément et créez un nouvel élément sous Demande d'accès. :

• Remplissez ensuite les informations pour la demande d'accès
  • Sélectionnez l'élément de gestion des utilisateurs pour connecter votre élément de demande d'accès.
  • Cliquez sur Créer pour finaliser l'élément.

• Ensuite, nous modifierons l'élément de gestion des utilisateurs
  • Revenez à l'élément de gestion des utilisateurs et modifiez-le.
  • Sélectionnez l'élément de demande d'accès comme composant d'approbation dans la gestion des utilisateurs.

Ça y est nous avons créé les éléments.

Étape 2 : Créer une API backend pour la connexion utilisateur

Avant d'utiliser les éléments, nous devons créer une API backend pour connecter l'utilisateur à l'élément permit,

Maintenant, regardons le code :

Code API diffusé au point de terminaison /api/v1/login_permit/?userkey=user_key :

Étape 3 : Code frontal pour la mise en œuvre de la connexion

Le code frontal pour implémenter la connexion ressemblera à ceci :

Ça y est nous avons mis en place notre code.

Étape 4 : Intégrer les Iframes dans le frontend

Il ne nous reste plus qu'à accéder au tableau de bord des permis et à copier à la fois l'iframe de gestion des utilisateurs et l'iframe de demande d'accès, comme indiqué ci-dessous :

Maintenant, une fois que nous avons le code, nous devons ajouter l' iframe à notre frontend où nous voulons montrer les éléments à nos utilisateurs, nous devons :

• Afficher l'élément de gestion des utilisateurs aux utilisateurs dotés du rôle d'administrateur.
• Afficher l'élément de demande d'accès aux utilisateurs ayant le rôle d'étudiant.

Grâce à cela, nous avons réussi à mettre en place un système d'approbation d'accès où les utilisateurs peuvent demander des mises à niveau de rôle, et les administrateurs peuvent approuver ou refuser ces demandes.

Démo de RBAC dans une application de partage de notes

• Démo : accès administrateur pour télécharger un widget

Cette démo montre comment un utilisateur doté du rôle « Admin » peut accéder au widget de téléchargement.

• Démo : restrictions relatives aux rôles d'étudiant et demande d'accès

Cette démo illustre comment un utilisateur doté du rôle « Étudiant » ne peut pas voir le widget de téléchargement et peut demander une mise à niveau vers le rôle « Administrateur » :

• Démo : Approbation de la mise à niveau de rôle

Cette démo montre comment les utilisateurs privilégiés peuvent approuver les demandes de mise à niveau de rôle :

• Démo : accès aux rôles amélioré pour télécharger un widget

Cette démo montre comment un utilisateur, après avoir été mis à niveau de « Étudiant » à « Administrateur », accède au widget de téléchargement.

Conclusion

C'est ça!

Merci d'avoir lu jusqu'ici.

Dans ce didacticiel, nous avons exploré l'autorisation et compris pourquoi l'autorisation est très importante dans toute application. Nous avons également examiné comment configurer Permit pour sécuriser l'application et contrôler l'accès des utilisateurs en fonction de leurs rôles.

Cet article n'est que la pointe de l'iceberg de l'autorisation et du modèle RBAC. Vous pouvez consulter ABAC et ReBAC pour une autorisation plus précise.