Les codeurs conquièrent l'infrastructure de sécurité en tant que série de codes : contrôle d'accès au niveau des fonctions manquant

C'est l'heure du prochain épisode de notre série Infrastructure as Code, des blogs qui permettront aux développeurs comme vous d'atteindre un tout nouveau niveau de sensibilisation à la sécurité lors du déploiement d'une infrastructure sécurisée au sein de votre propre organisation.

Oh, au fait... comment avez-vous relevé le défi posé par les erreurs de configuration de sécurité dans le blog précédent ? Si vous souhaitez vous attaquer dès maintenant à une vulnérabilité de contrôle d'accès au niveau fonctionnel manquante, rendez-vous sur la plateforme :

(Le lien ci-dessus vous mènera au défi Kubernetes, mais une fois sur la plateforme, utilisez le menu déroulant pour choisir entre Ansible, CloudFormation, Terraform ou Docker. Votre choix).

Presque toutes les applications déployées aujourd'hui disposent d'un mécanisme de contrôle d'accès qui vérifie si un utilisateur est autorisé à exécuter les fonctions demandées. C'est à peu près la pierre angulaire d'une sécurité et d'une fonctionnalité efficaces lors de la création d'une application. En fait, toutes les applications Web ont besoin de contrôles d'accès afin de permettre aux utilisateurs disposant de privilèges différents d'utiliser le programme.

Des problèmes peuvent toutefois survenir lorsque ces mêmes fonctions de vérification pour le contrôle d'accès ne sont pas exécutées au niveau de l'infrastructure ou sont mal configurées. Sans un contrôle d'accès parfait au niveau de l'infrastructure, toute une entreprise s'ouvre aux pirates informatiques, qui peuvent utiliser cette vulnérabilité comme passerelle pour espionner sans autorisation ou lancer une attaque complète.

En fait, il est extrêmement facile d'exploiter les vulnérabilités de contrôle d'accès aux fonctions manquantes ou mal configurées. Les attaquants n'ont même pas besoin d'être trop doués. Ils ont juste besoin de savoir quelles commandes exécutent des fonctions dans n'importe quel framework supportant l'application. S'ils le font, ce n'est qu'une question d'essais et d'erreurs. Ils peuvent continuellement soumettre des demandes qui ne devraient pas être autorisées, et dès que l'une d'elles aboutit, le site Web, l'application, le serveur ou même l'ensemble du réseau peuvent être exposés.

Comment fonctionnent les exploits de contrôle d'accès au niveau des fonctions manquants ?

Les contrôles d'accès au niveau des fonctions peuvent s'introduire dans une organisation de plusieurs manières. Par exemple, l'accès au niveau des fonctions peut être laissé à une application et ne pas être vérifié par l'infrastructure sous-jacente. Ou bien, le contrôle d'accès au niveau de l'infrastructure peut être mal configuré. Dans certains cas, les administrateurs partent du principe que les utilisateurs non autorisés ne sauront pas comment accéder à des ressources d'infrastructure que seuls les utilisateurs de niveau supérieur devraient pouvoir voir et utilisent un modèle de « sécurité par l'obscurité » qui fonctionne rarement.

À titre d'exemple de sécurité par l'obscurité, l'URL suivante est probablement vulnérable aux attaques :

http://companywebsite.com/app/NormalUserHomepage

Si un utilisateur authentifié utilise une technique appelée navigation URL forcée, il peut essayer d'accéder à une page réservée aux administrateurs. Voici un exemple :

http://companywebsite.com/app/AdminPages

S'il n'existe aucune vérification côté serveur, les pages d'administration leur seront simplement affichées (si leur nom correspond à la demande) et auront ensuite accès à toutes les fonctions supplémentaires que les administrateurs peuvent utiliser à partir de la nouvelle page. Si le serveur renvoie une erreur « page introuvable » à l'attaquant, celui-ci peut simplement continuer à essayer jusqu'à ce qu'il trouve le nom donné à la page d'administration.

Pour les attaquants, exploiter contrôles d'accès au niveau des fonctions manquants est un processus similaire. Au lieu d'essayer de parcourir des pages non autorisées, ils envoient plutôt des demandes de fonction. Par exemple, ils peuvent essayer de créer un nouvel utilisateur avec des droits d'administrateur. Leur demande ressemblerait donc à ceci, selon le framework :

Post/Action/CreateUser Name=hacker&pw=password&role=admin

S'il n'existe aucun contrôle d'accès au niveau des fonctions, l'exemple ci-dessus serait réussi et un nouveau compte administrateur serait créé. Une fois que l'attaquant se reconnectera en tant que nouvel administrateur, il aura le même accès et les mêmes autorisations que tout autre administrateur sur ce réseau ou ce serveur.

Le correctif pour les contrôles d'accès au niveau des fonctions manquants

Comme il est si facile pour les attaquants d'exploiter les vulnérabilités manquantes en matière de contrôle d'accès au niveau des fonctions, il est essentiel de les détecter, de les corriger et de les empêcher. Heureusement, ce n'est pas trop difficile avec un peu de savoir-faire et une infrastructure de base car Formation à la sécurité du code.

La principale protection proviendra de la mise en œuvre de l'autorisation basée sur les rôles au niveau de l'infrastructure. Ne faites jamais confiance aux applications pour gérer cette fonction. Même s'ils le font, le fait de disposer d'une autorisation côté infrastructure garantira que rien n'est oublié. Idéalement, l'autorisation doit provenir d'un emplacement centralisé (par exemple, AWS IAM, Azure IAM, etc.) intégré à la routine de votre organisation et appliqué à chaque nouvelle application. Ces processus d'autorisation peuvent provenir du framework lui-même ou d'un certain nombre de modules externes faciles à utiliser.

Enfin, votre organisation doit adopter le concept du moindre privilège. Toutes les actions et fonctions doivent être refusées par défaut, le processus d'autorisation étant utilisé pour donner aux utilisateurs valides l'autorisation de faire ce dont ils ont besoin. Les autorisations nécessaires ne devraient leur être accordées que pour exécuter la fonction requise, et uniquement pour la durée requise.

L'absence de contrôles d'accès au niveau des fonctions peut être dévastatrice. Heureusement, en mettant en place de bonnes pratiques d'autorisation au niveau de l'infrastructure au sein de votre organisation, vous pouvez facilement éviter que ce problème ne se produise.

Vous pensez être prêt à détecter un bogue de contrôle d'accès dans la nature ? Comparez ces extraits de code Docker, l'un vulnérable, l'autre sécurisé :

Vulnérable :

DEPUIS quay.io/prometheus/busybox:latest
VERSION ARG = 0.12.1
Nom de fichier ARG = MySQLD_Exporter-$ {VERSION} .linux-amd64
URL ARG = https://github.com/prometheus/mysqld_exporter/releases/download/v
EXÉCUTEZ wget $URL$VERSION/$filename.tar.gz && \
tar -xvf $Filename.tar.gz && \
mv $FileName/MySQLD_Exporter /bin/mysqld_exporter
COPIEZ .my.cnf /home/.my.cnf
COPIE. /scripts/entrypoint.sh ~/entrypoint.sh
Utilisateur root
EXPOSER 9104
POINT D'ENTRÉE [« sh », "~/entrypoint.sh"]
CMD [« /bin/mysqld_exporter »]

Sicher:

DEPUIS quay.io/prometheus/busybox:latest
VERSION ARG = 0.12.1
Nom de fichier ARG = MySQLD_Exporter-$ {VERSION} .linux-amd64
URL ARG = https://github.com/prometheus/mysqld_exporter/releases/download/v
EXÉCUTEZ wget $URL$VERSION/$filename.tar.gz && \
tar -xvf $Filename.tar.gz && \
mv $FileName/MySQLD_Exporter /bin/mysqld_exporter
COPIEZ .my.cnf /home/.my.cnf
COPIE. /scripts/entrypoint.sh ~/entrypoint.sh
UTILISATEUR : personne
EXPOSER 9104
POINT D'ENTRÉE [« sh », "~/entrypoint.sh"]
CMD [« /bin/mysqld_exporter »]

Apprenez-en plus, lancez-vous des défis

Siehe Secure Code Warrior auf den Blog-Seiten, um mehr über diese Sicherheitslücke zu erfahren und zu erfahren, wie Sie Ihr Unternehmen und Ihre Kunden vor den Folgen weiterer Sicherheitslücken und Schwachstellen schützen können.

Et si vous l'avez manqué plus tôt, vous pouvez essayez un défi de sécurité gamifié avec IaC sur la plateforme Secure Code Warrior pour perfectionner et mettre à jour toutes vos compétences en matière de cybersécurité.

Restez à l'affût du prochain chapitre !