Politique d'autorisation d'Apache APISIX : Protégez vos APIs

Qi Guo

Qi Guo

April 21, 2023

Technology

Introduction

Aujourd'hui, les API sont devenues le pont reliant divers systèmes et applications en termes de données et de fonctionnalités. Tout en profitant de la commodité des API, garantir la sécurité des données et éviter les fuites de données ainsi que d'autres problèmes de sécurité sont devenus les principales préoccupations des utilisateurs. À ce stade, le contrôle d'accès joue un rôle crucial. En établissant des politiques de contrôle d'accès appropriées pour les API, vous pouvez non seulement protéger les API contre d'énormes attaques cybernétiques et assurer la sécurité des données, mais aussi aider les entreprises à répondre aux exigences de conformité et à renforcer la confiance des clients.

Apache APISIX est une passerelle API cloud-native dynamique, en temps réel et haute performance, offrant un riche ensemble de fonctionnalités de gestion du trafic telles que l'équilibrage de charge, l'amont dynamique, la publication canari, la rupture de service, l'authentification et l'observabilité. Dans cet article, nous présenterons les politiques de contrôle d'accès d'Apache APISIX et discuterons des stratégies courantes qui peuvent être utilisées pour protéger la sécurité de votre API et assurer le fonctionnement stable de votre système.

Qu'est-ce qu'une politique de contrôle d'accès ?

Les politiques de contrôle d'accès sont des mécanismes de sécurité conçus pour protéger les données ou ressources sensibles dans les systèmes informatiques, réseaux ou applications, en s'assurant que seuls les utilisateurs ou applications autorisés peuvent y accéder. Cela permet de réduire le risque de fuites de données et de vulnérabilités de sécurité. Dans une passerelle API, les politiques de contrôle d'accès sont un composant essentiel. En tant que point d'entrée de tout le trafic, la passerelle API est responsable de la réception et du transfert de toutes les requêtes API. Par conséquent, les politiques de contrôle d'accès de la passerelle API déterminent directement la sécurité et la stabilité des services en amont.

Politiques de contrôle d'accès courantes dans Apache APISIX

Apache APISIX offre un riche ensemble de politiques de contrôle d'accès, prenant en charge le protocole d'authentification OAuth 2.0 et s'intégrant à divers services d'authentification externes tels que Keycloak, Ory Hydra, Okta, Auth0, et plus encore. En plus de prendre en charge les services d'authentification externes, APISIX fournit également des méthodes d'authentification internes puissantes. Combiné à l'objet Consumer d'APISIX, vous pouvez librement mélanger et assortir des plugins d'authentification, d'autorisation, de limitation de débit, de liste noire et de liste blanche d'IP pour protéger vos API et empêcher efficacement les requêtes malveillantes d'endommager vos services API.

schematic

1. Contrôle d'accès basé sur l'IP

Le contrôle d'accès basé sur l'IP est la méthode la plus simple et la plus directe, qui peut restreindre l'accès à votre API uniquement aux requêtes provenant d'adresses spécifiques.

Vous pouvez utiliser le plugin ip-restriction d'APISIX pour activer cette fonctionnalité, qui offre diverses options de configuration, telles que des listes d'adresses IP autorisées ou refusées, des plages d'adresses IP et des messages d'erreur renvoyés lors du refus de requêtes. Vous pouvez configurer ces options selon vos besoins pour obtenir un contrôle d'accès plus fin. Il est important de noter que le contrôle d'accès basé sur l'IP peut avoir certaines limites, car les adresses IP peuvent être usurpées ou partagées. Par conséquent, lors de l'utilisation du plugin ip-restriction, il est préférable de le combiner avec d'autres plugins de contrôle d'accès pour améliorer la sécurité et la flexibilité de votre système.

2. Contrôle d'accès basé sur une clé API

Ce contrôle d'accès est une stratégie très courante de contrôle d'accès aux API. Son principe de base est d'authentifier et d'autoriser les requêtes via une clé API pré-générée, ce qui permet d'ajouter rapidement des mécanismes d'authentification aux API. Cependant, il est important de protéger la clé API pour éviter qu'elle ne fuite et ne subisse des attaques malveillantes.

Le plugin key-auth d'APISIX peut facilement ajouter des mécanismes d'authentification à vos API, en ajoutant la clé à la chaîne de requête ou à l'en-tête pour l'authentification lors de l'envoi des requêtes. Dans la version 3.1 d'APISIX et ultérieures, il prend également en charge le chiffrement et le stockage des clés API dans etcd en utilisant la configuration encrypted storage fields data_encryption, renforçant ainsi la sécurité de votre API.

3. Contrôle d'accès basé sur un jeton

Cette méthode est mise en œuvre en ajoutant un champ d'authentification contenant un jeton dans l'en-tête de la requête. Un jeton est une clé, généralement une chaîne ou un nombre, utilisée pour vérifier si l'expéditeur d'une requête API a la permission d'accéder à l'API. Typiquement, un jeton contient l'identité et les permissions de l'utilisateur, permettant au serveur de déterminer si l'utilisateur a la permission d'accès lorsqu'il initie une requête API et de prendre des décisions d'autorisation ou de refus appropriées.

APISIX fournit le plugin jwt-auth pour utiliser cette stratégie de contrôle d'accès, prenant en charge des options de configuration telles que l'emplacement de stockage du jeton, la durée de validité du jeton, l'algorithme de signature JWT et les clés. Vous pouvez configurer ces options selon vos besoins pour répondre à différentes exigences d'authentification.

4. Contrôle d'accès basé sur le chemin de la requête

Le contrôle d'accès basé sur le chemin de la requête est réalisé en filtrant et en faisant correspondre les chemins de requête pour contrôler l'accès à des API, services ou ressources spécifiques. Cette stratégie est couramment utilisée dans des scénarios nécessitant un contrôle d'accès granulaire sur les ressources, comme la protection de données sensibles ou le contrôle de l'accès de certains utilisateurs à des ressources spécifiques au sein du système.

Le plugin uri-blocker d'APISIX prend en charge la configuration de listes de règles regex pour intercepter les URI de requête des utilisateurs, et la configuration de rejected_code et rejected_msg pour spécifier le code d'état HTTP et le corps de réponse renvoyés après une interception réussie. Cela permet aux administrateurs de contrôler finement les permissions des utilisateurs et d'améliorer la sécurité et la contrôlabilité des API.

5. Politique de contrôle d'accès basée sur ACL

ACL (Access Control List) est une politique de contrôle d'accès basée sur des listes, utilisée pour contrôler les permissions d'accès des utilisateurs ou groupes d'utilisateurs aux ressources. Son principe de base est de définir une liste ACL pour chaque ressource, listant les utilisateurs ou groupes d'utilisateurs autorisés à accéder à la ressource. Lorsqu'un utilisateur demande l'accès à la ressource, son accès est déterminé en fonction de la liste ACL correspondante.

Dans APISIX, nous pouvons utiliser le plugin consumer-restriction pour activer cette fonctionnalité. Les administrateurs peuvent facilement contrôler quels utilisateurs ou groupes d'utilisateurs peuvent accéder à des ressources spécifiques et empêcher les utilisateurs non autorisés d'envoyer des requêtes vers des zones sensibles, évitant ainsi les fuites de données sensibles.

Introduction au scénario : Contrôle d'accès plus granulaire

Dans des scénarios d'application réels, nous mettons souvent en œuvre un contrôle d'accès plus granulaire pour les ressources contenant des données sensibles. Par exemple, nous avons maintenant deux utilisateurs, A et B, qui utilisent les mêmes méthodes d'authentification internes, comme key-auth ou basic-auth. Nous souhaitons également appliquer un contrôle d'accès plus granulaire à l'utilisateur B, en lui interdisant d'accéder à certaines API.

schematic_2

Nous pouvons utiliser le plugin consumer-restriction d'APISIX pour un contrôle plus granulaire. Ce plugin vous permet de définir des restrictions d'accès basées sur Route, Service ou Consumer, et il prend en charge la configuration de quatre valeurs d'attribut type :

  • consumer_name : Restreindre l'accès du Consumer à Route ou Service en listant le username du Consumer dans une liste blanche ou noire.
  • consumer_group_id : Restreindre l'accès du Consumer à Route ou Service en listant l'id du groupe Consumer dans une liste blanche ou noire.
  • service_id : Restreindre l'accès du Consumer à Service en listant l'id du Service dans une liste blanche ou noire. Cela doit être utilisé conjointement avec un plugin d'autorisation.
  • route_id : Restreindre l'accès du Consumer à Route en listant l'id de la Route dans une liste blanche ou noire.

Dans ce scénario, nous pouvons utiliser deux méthodes de configuration pour empêcher l'utilisateur B d'accéder à une ressource API spécifique.

Configuration de la politique de contrôle d'accès dans Route

  1. Tout d'abord, nous devons créer deux objets Consumer sur APISIX et activer le plugin basic-auth, avec les noms userA et userB.
curl http://127.0.0.1:9180/apisix/admin/consumers -H 'X-API-KEY: {YOUR_API_KEY}' -X PUT -i -d '
{
  "username": "userA",
  "plugins": {
    "basic-auth": {
      "username":"userA",
      "password": "123456"
    }
  }
}'
curl http://127.0.0.1:9180/apisix/admin/consumers -H 'X-API-KEY: {YOUR_API_KEY}' -X PUT -i -d '
{
  "username": "userB",
  "plugins": {
    "basic-auth": {
      "username":"userB",
      "password": "123456"
    }
  }
}'
  1. Ensuite, nous activons et configurons la propriété whitelist de consumer-restriction sur la route où nous devons appliquer la restriction et ajoutons le username du consumer userA précédemment créé. De cette façon, la route n'acceptera que les requêtes de userA.
curl http://127.0.0.1:9180/apisix/admin/routes/1 -H 'X-API-KEY: {YOUR_API_KEY}' -X PUT -d '
{
  "uri": "/get",
  "upstream": {
    "type": "roundrobin",
    "nodes": {
      "httpbin.org:80": 1
    }
  },
  "plugins": {
    "basic-auth": {},
    "consumer-restriction": {
      "whitelist": [
        "userA"
      ]
    }
  }
}'
  1. Envoyez des requêtes d'accès séparément en utilisant userA et userB.
curl -u userA:123456 http://127.0.0.1:9080/get -i
HTTP/1.1 200 OK

curl -u userB:123456 http://127.0.0.1:9080/get -i
HTTP/1.1 403 Forbidden
...
{"message":"The consumer_name is forbidden."}

Le résultat indique que userB a été restreint d'accéder à la ressource API.

Configuration des politiques de contrôle des permissions dans Consumer

  1. Tout d'abord, nous allons configurer une route dont l'ID est forbidden-userB, et activer le plugin basic-auth.
curl http://127.0.0.1:9180/apisix/admin/routes -H 'X-API-KEY: {YOUR_API_KEY}' -X PUT -d '
{
  "id": "forbidden-userB",
  "uri": "/get",
  "upstream": {
    "type": "roundrobin",
    "nodes": {
      "httpbin.org:80": 1
    }
  },
  "plugins": {
    "basic-auth": {}
  }
}'
  1. Créez deux objets Consumer et activez le plugin basic-auth. Notez que nous devons configurer le plugin consumer-restriction pour affiner les politiques de contrôle des permissions pour userB.
curl http://127.0.0.1:9180/apisix/admin/consumers -H 'X-API-KEY: {YOUR_API_KEY}' -X PUT -i -d '
{
  "username": "userA",
  "plugins": {
    "basic-auth": {
      "username":"userA",
      "password": "123456"
    }
  }
}'
curl http://127.0.0.1:9180/apisix/admin/consumers -H 'X-API-KEY: {YOUR_API_KEY}' -X PUT -i -d '
{
  "username": "userB",
  "plugins": {
    "basic-auth": {
      "username":"userB",
      "password": "123456"
    },
    "consumer-restriction": {
      "type": "route_id",
      "blacklist": [
        "forbidden-userB"
      ],
      "rejected_code": 403
    }
  }
}'
  1. Envoyez des requêtes en utilisant userA et userB séparément.
curl -u userA:123456 http://127.0.0.1:9080/get -i
HTTP/1.1 200 OK

curl -u userB:123456 http://127.0.0.1:9080/get -i
HTTP/1.1 403 Forbidden
...
{"message":"The route_id is forbidden."}

En examinant les résultats des tests, nous pouvons vérifier que les requêtes de userB ont été efficacement limitées.

Conclusion

Cet article présente les politiques de contrôle des permissions couramment utilisées dans APISIX et illustre comment les activer et les configurer dans APISIX à l'aide d'un scénario classique. Le contrôle des permissions est une stratégie répandue dans les passerelles API. APISIX offre non seulement une suite complète de plugins prêts à l'emploi pour l'authentification, mais fournit également un soutien étendu dans des domaines tels que la sécurité, la gestion du trafic et l'observabilité. En sélectionnant et en configurant vos règles de politique de contrôle des permissions, vous pouvez facilement renforcer la sécurité de vos API.

Tags:
APISIX Basics
Authentication & Authorization
API Gateway Policy
Plugin