Prévenir les failles de contrôle d’accès dans les applications Python Flask

Certains problèmes de sécurité peuvent être facilement détectés par des outils d’analyse statique comme Snyk, tandis que d’autres relèvent de subtilités logiques pouvant être intentionnelles ou accidentelles. Les failles de contrôle d’accès font partie de ces problèmes. Si vous développez des applications Python Flask pour des applications métier modernes de type SaaS, cette vulnérabilité vous concerne certainement.

Le contrôle d’accès est un aspect fondamental de la sécurité des applications : il garantit que les utilisateurs peuvent uniquement accéder à leurs propres ressources ou à celles pour lesquelles ils disposent d’une autorisation. Lorsque les mécanismes de contrôle d’accès dans les applications Python sont faibles ou mal implémentés dans la logique métier, des acteurs malveillants peuvent les exploiter pour obtenir un accès non autorisé, entraînant de graves failles de sécurité et une hausse des risques.

Commençons par clarifier quelques termes de sécurité afin de mieux comprendre les failles de contrôle d’accès sous l’angle de la sécurité.

Qu’est-ce qu’une faille de contrôle d’accès ?

Une faille de contrôle d’accès est une vulnérabilité critique qui survient lorsqu’une application n’applique pas les restrictions (contrôles d’autorisation) concernant les actions que les utilisateurs authentifiés peuvent effectuer. Cette vulnérabilité figure au premier rang des risques de sécurité de l’OWASP Top 10 de 2021. Elle permet aux attaquants d’accéder à des ressources non autorisées ou d’effectuer des actions au-delà de leurs autorisations, par exemple modifier, créer ou supprimer des enregistrements.

Fortement recommandé : suivez dès maintenant, dans votre navigateur, le cours Snyk sur les failles de contrôle d’accès, gratuit et rapide !

Exemple de faille de contrôle d’accès dans une application Python Flask

Cette section présente un exemple courant de faille de contrôle d’accès dans une application Python Flask. L’extrait de code illustre une vulnérabilité due à des vérifications insuffisantes du contrôle d’accès dans le code Python. Dans cet exemple, les contrôles d’autorisation ne sont pas seulement insuffisants : ils sont totalement absents. Si cette application Python était déployée avec un accès public, même des utilisateurs authentifiés pourraient exploiter ce type de vulnérabilité pour effectuer des actions non autorisées ou accéder à des données auxquelles ils ne devraient pas avoir accès.

Exemple de code : application Python Flask vulnérable

Voici le code d’une application Flask simple en Python qui présente une faille de contrôle d’accès :

from flask import Flask, render_template, request, redirect, url_for

app = Flask(__name__)

# Service to handle user account information
class AccountManager:
    def retrieve_account_details(self, account_identifier):
        """Fetches the account details based on the provided identifier."""
        # Database interaction to retrieve account data
        pass

    def save_account_changes(self, modified_account):
        """Persists the updated account information to the database."""
        # Database interaction to update account data
        pass

account_manager = AccountManager()

def is_user_logged_in():
    """Determines if a user is currently authenticated."""
    # Logic to check user authentication status
    return True # Replace with actual authentication check

@app.route('/update-account', methods=['POST'])
def update_account():
    """Handles the submission of updated account information."""
    if not is_user_logged_in():
        return redirect(url_for('login'))

    account_name = request.form.get('username')
    account_record = account_manager.retrieve_account_details(account_name)

    if account_record.get_username() == account_name:
        account_manager.save_account_changes(account_record)

        return redirect(url_for('/user'))

@app.route('/user')
def user_home():
    """Displays the user's dashboard."""
    return render_template('dashboard.html')

if __name__ == '__main__':
    app.run(debug=False)

Analyse des vulnérabilités du code

La faille d’autorisation dans ce code Python réside dans l’absence de vérifications adéquates du contrôle d’accès lors de la mise à jour d’un profil utilisateur. La fonction `update-account` récupère le nom d’utilisateur à partir des données du formulaire (via le champ de formulaire `username`), puis récupère le profil utilisateur correspondant. Elle vérifie ensuite que le nom d’utilisateur du formulaire correspond à celui du profil récupéré avant de le mettre à jour.

Toutefois, cette vérification ne garantit pas que l’utilisateur à l’origine de la requête est bien celui qui est autorisé à mettre à jour le profil. Un attaquant pourrait modifier les données du formulaire pour indiquer un autre nom d’utilisateur et ainsi obtenir un accès non autorisé lui permettant de mettre à jour le profil d’un autre utilisateur.

Pour remédier à cette vulnérabilité, l’application doit mettre en place des mesures de contrôle d’accès plus strictes. Elle doit notamment vérifier que l’utilisateur à l’origine de la requête est bien propriétaire du profil à mettre à jour. Pour cela, la session de l’utilisateur peut être associée au profil, afin de garantir que seul l’utilisateur authentifié puisse mettre à jour son profil.

Vulnérabilités courantes associées aux failles de contrôle d’accès

Comme nous l’avons vu, il est facile de passer à côté d’une faille d’autorisation, car il s’agit le plus souvent d’un problème de logique. Tout le monde devrait-il pouvoir consulter ou modifier les données des autres, ou s’agit-il d’un bug ? À quel niveau faut-il appliquer les contrôles ? La sécurité au niveau des lignes de la base de données suffit peut-être déjà à protéger ces données.

Examinons d’autres vulnérabilités et risques de sécurité pouvant avoir de graves conséquences et découler de failles de contrôle d’accès :

• Références directes non sécurisées à des objets (IDOR) : ce problème survient lorsqu’une application expose la référence à un objet interne, tel qu’un fichier ou une clé de base de données (par exemple, la clé primaire `id` d’une table), sans effectuer de vérifications adéquates du contrôle d’accès. Les attaquants peuvent manipuler ces références pour accéder directement à des données non autorisées, car il leur est facile de deviner l’identifiant.

• Absence de contrôle d’accès au niveau des fonctions : cette vulnérabilité survient lorsqu’une application n’applique pas de contrôle d’accès au niveau des fonctions ou des méthodes, ce qui permet à des utilisateurs non autorisés d’exécuter des actions restreintes.

• Élévation de privilèges : ce problème survient lorsqu’un attaquant obtient des autorisations supérieures à celles prévues, souvent en exploitant des failles dans la logique de contrôle d’accès. Par exemple, si l’attaquant peut modifier les identifiants ou l’adresse e-mail du compte administrateur, il peut faire passer son compte au niveau de ce compte administrateur et obtenir des privilèges plus élevés dans le système vulnérable.

• Falsification de requête intersites (CSRF) : bien qu’il ne s’agisse pas à proprement parler d’un problème de contrôle d’accès, le CSRF peut déclencher des actions non autorisées au nom d’un utilisateur authentifié.

Impact des failles de contrôle d’accès sur la sécurité des applications

Les conséquences des failles de contrôle d’accès sur la sécurité des applications, et notamment des applications Python Flask, peuvent être dévastatrices. Un accès non autorisé à des données sensibles peut entraîner des violations de données, porter atteinte à la vie privée des utilisateurs et compromettre la conformité réglementaire. Comme le montrent les exemples ci-dessus, les attaquants peuvent également manipuler ou supprimer des données, perturber le fonctionnement de l’application et même prendre le contrôle de toute son infrastructure.

Comprendre et atténuer les failles de contrôle d’accès est essentiel pour que les développeurs préservent la sécurité et l’intégrité de leurs applications. La mise en place de mécanismes de contrôle d’accès robustes, des tests de sécurité approfondis et l’utilisation d’outils comme Snyk Code pour détecter les pratiques de codage non sécurisées peuvent aider à repérer et à corriger ces vulnérabilités avant qu’elles ne soient exploitées par des acteurs malveillants.

Étapes suivantes pour prévenir les failles de contrôle d’accès

Pour en savoir plus sur la prévention des failles de contrôle d’accès, consultez les recommandations de l’OWASP et envisagez d’utiliser des outils comme Snyk Code pour détecter et corriger les vulnérabilités de votre code. Vous pouvez créer un compte Snyk. C’est gratuit !

Voici des ressources pédagogiques recommandées pour prévenir les failles de contrôle d’accès et former votre équipe de développement à se protéger contre les accès non autorisés :

• Suivez le parcours Snyk Learn consacré à l’OWASP Top 10, qui commence par un programme interactif sur les failles de contrôle d’accès et présente des conseils et des bonnes pratiques.

• Les utilisateurs de JavaScript et Node.js peuvent consulter le guide Prévenir les failles de contrôle d’accès dans les applications Express Node.js.

• Si vous vous préoccupez de l’authentification et de l’autorisation, vous développez probablement des backends liés aux API. Dans ce cas, consultez les 10 principaux risques de sécurité des API selon l’OWASP.