Flask-Security : ajout de l'authentification des utilisateurs et du cryptage des mots de passe aux applications Web Python

Flask-Security : ajoutez l'authentification des utilisateurs et le cryptage des mots de passe aux applications Web Python

Avec le développement continu d'Internet, de plus en plus d'applications nécessitent une authentification des utilisateurs et un cryptage des mots de passe pour protéger la sécurité des données des utilisateurs. Dans le langage Python, il existe un framework web très populaire-Flask. Flask-Security est une bibliothèque d'extensions basée sur le framework Flask qui aide les développeurs à ajouter facilement des fonctionnalités d'authentification des utilisateurs et de cryptage des mots de passe aux applications Web Python.

Flask-Security présente les fonctionnalités suivantes :

• Peut être facilement intégré aux applications Flask existantes
• Prend en charge plusieurs méthodes d'authentification, notamment les mots de passe, les jetons, les connexions aux réseaux sociaux, etc.
• Prend en charge le cryptage et le décryptage des mots de passe (en utilisant le cryptage Bcrypt algorithme)
• Fournit des fonctions de gestion des rôles d'utilisateur, qui peuvent attribuer différents rôles à différents utilisateurs pour contrôler l'accès des utilisateurs aux applications

Dans cet article, nous présenterons comment utiliser Flask-Security pour ajouter des capacités d'authentification utilisateur et de cryptage de mot de passe à Applications Web Python.

Installer Flask-Security

Avant de commencer à utiliser Flask-Security, nous devons d'abord l'installer. Nous pouvons utiliser pip pour installer Flask-Security :

pip install Flask-Security

Bien sûr, nous devons également installer d'autres bibliothèques dépendantes nécessaires, notamment Flask et Flask-SQLAlchemy (ou d'autres bibliothèques ORM) :

pip install Flask Flask-SQLAlchemy

Configurer Flask-Security

Dans l'installation Après avoir terminé Flask-Security, nous devons configurer certains paramètres pour activer les fonctions d'authentification des utilisateurs et de cryptage des mots de passe. Tout d'abord, nous devons introduire la bibliothèque d'extension Flask-Security dans l'application Flask :

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_security import Security, SQLAlchemyUserDatastore, UserMixin, RoleMixin, login_required

Ensuite, nous devons définir certains paramètres de configuration nécessaires, y compris les informations de connexion à la base de données, les clés, etc. :

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
app.config['SECRET_KEY'] = 'mysecretkey'

Ici, nous utilisons SQLite comme notre base de données et enregistrez-la dans un fichier. Bien entendu, vous pouvez également utiliser d'autres bases de données (telles que MySQL ou PostgreSQL), il suffit de modifier les informations de connexion à la base de données correspondante.

Ensuite, nous devons définir une classe User et une classe Role. Ici, nous utilisons SQLAlchemy comme bibliothèque ORM :

db = SQLAlchemy(app)


class Role(db.Model, RoleMixin):
    id = db.Column(db.Integer(), primary_key=True)
    name = db.Column(db.String(80), unique=True)
    description = db.Column(db.String(255))


class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(255), unique=True)
    password = db.Column(db.String(255))
    active = db.Column(db.Boolean())
    confirmed_at = db.Column(db.DateTime())
    roles = db.relationship('Role', secondary='user_roles',
                             backref=db.backref('users', lazy='dynamic'))


user_datastore = SQLAlchemyUserDatastore(db, User, Role)


class UserRoles(db.Model):
    id = db.Column(db.Integer(), primary_key=True)
    user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
    role_id = db.Column(db.Integer(), db.ForeignKey('role.id'))

Ici, nous définissons une classe User et une classe Role et les associons respectivement à la table user_roles. Nous définissons également un objet user_datastore pour gérer les informations sur les utilisateurs et les rôles.

Ensuite, nous devons configurer les paramètres et les classes que nous avons définis via la bibliothèque d'extension de sécurité :

security = Security(app, user_datastore)

À ce stade, nous avons terminé la configuration de Flask-Security. Ensuite, nous pouvons utiliser la fonctionnalité d'authentification des utilisateurs et de cryptage des mots de passe dans notre application Flask.

Utilisez Flask-Security pour l'authentification des utilisateurs et le cryptage des mots de passe

Avant d'utiliser Flask-Security, nous devons créer un nouveau plan Flask et y définir certaines fonctions d'affichage pour gérer la connexion, l'enregistrement, la déconnexion et d'autres opérations de l'utilisateur :

from flask import Blueprint, render_template, redirect, url_for, request
from flask_security import login_user, logout_user, current_user, login_required

security_blueprint = Blueprint('security', __name__)


@security_blueprint.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        email = request.form.get('email')
        password = request.form.get('password')
        user = user_datastore.find_user(email=email)
        if user is not None and user.password == password:
            login_user(user)
            return redirect(url_for('index'))
        return redirect(url_for('login'))
    return render_template('login.html')


@security_blueprint.route('/logout')
@login_required
def logout():
    logout_user()
    return redirect(url_for('index'))


@security_blueprint.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'POST':
        email = request.form.get('email')
        password = request.form.get('password')
        user = user_datastore.create_user(email=email, password=password)
        user_datastore.add_role_to_user(user, 'user')
        db.session.commit()
        login_user(user)
        return redirect(url_for('index'))
    return render_template('register.html')

Ici, nous définissons trois fonctions d'affichage : connexion, déconnexion et inscription. La fonction de connexion est utilisée pour traiter les opérations de connexion des utilisateurs, la fonction d'enregistrement est utilisée pour traiter les opérations d'enregistrement des utilisateurs et la fonction de déconnexion est utilisée pour traiter les opérations de déconnexion des utilisateurs. Parmi elles, nous utilisons les fonctions login_user et logout_user fournies par Flask-Security pour implémenter les fonctions de connexion et de déconnexion des utilisateurs. Dans la fonction de registre, nous utilisons les fonctions user_datastore.create_user et user_datastore.add_role_to_user pour créer un nouvel utilisateur et lui attribuer un rôle d'utilisateur par défaut.

Ici, nous utilisons le moteur de modèles de Flask pour restituer les pages HTML. Pour plus de détails, veuillez vous référer à la documentation du moteur de modèles de Flask.

Enfin, nous devons enregistrer ce plan dans notre application Flask :

app.register_blueprint(security_blueprint)

À ce stade, nous avons fini d'utiliser Flask-Security. Maintenant, nous pouvons lancer notre application Flask et y accéder via le navigateur.

Résumé

Dans cet article, nous avons expliqué comment utiliser Flask-Security pour ajouter des fonctionnalités d'authentification utilisateur et de cryptage de mot de passe à une application Web Python. En étudiant cet article, nous pouvons comprendre l'utilisation de base de Flask-Security et comprendre certaines de ses caractéristiques et précautions. Dans les applications réelles, nous pouvons librement personnaliser et étendre les fonctions de Flask-Security selon nos besoins pour répondre à nos besoins.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!