Flask-Security: Hinzufügen von Benutzerauthentifizierung und Passwortverschlüsselung zu Python-Webanwendungen

Flask-Sicherheit: Benutzerauthentifizierung und Passwortverschlüsselung zu Python-Webanwendungen hinzufügen

Mit der kontinuierlichen Entwicklung des Internets erfordern immer mehr Anwendungen Benutzerauthentifizierung und Passwortverschlüsselung, um die Sicherheit der Benutzerdaten zu schützen. In der Python-Sprache gibt es ein sehr beliebtes Web-Framework – Flask. Flask-Security ist eine Erweiterungsbibliothek, die auf dem Flask-Framework basiert und Entwicklern hilft, Python-Webanwendungen auf einfache Weise Benutzerauthentifizierungs- und Passwortverschlüsselungsfunktionen hinzuzufügen.

Flask-Security verfügt über die folgenden Funktionen:

• Kann problemlos in bestehende Flask-Anwendungen integriert werden
• Unterstützt mehrere Authentifizierungsmethoden, einschließlich Passwörter, Token, Social-Media-Anmeldungen usw.
• Unterstützt die Passwortverschlüsselung und -entschlüsselung (mit Bcrypt-Verschlüsselung). Algorithmus)
• Bietet Benutzerrollenverwaltungsfunktionen, die verschiedenen Benutzern unterschiedliche Rollen zuweisen können, um den Zugriff der Benutzer auf Anwendungen zu steuern

In diesem Artikel stellen wir vor, wie Sie Flask-Security verwenden, um Benutzerauthentifizierungs- und Passwortverschlüsselungsfunktionen hinzuzufügen Python-Webanwendungen.

Flask-Security installieren

Bevor wir Flask-Security verwenden, müssen wir es zuerst installieren. Wir können pip verwenden, um Flask-Security zu installieren:

pip install Flask-Security

Natürlich müssen wir auch einige andere notwendige abhängige Bibliotheken installieren, einschließlich Flask und Flask-SQLAlchemy (oder andere ORM-Bibliotheken):

pip install Flask Flask-SQLAlchemy

Konfigurieren Sie Flask-Security

In Die Installation Nach Abschluss von Flask-Security müssen wir einige Parameter konfigurieren, um Benutzerauthentifizierungs- und Passwortverschlüsselungsfunktionen zu aktivieren. Zuerst müssen wir die Flask-Security-Erweiterungsbibliothek in die Flask-Anwendung einführen:

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

Als nächstes müssen wir einige notwendige Konfigurationsparameter definieren, einschließlich Datenbankverbindungsinformationen, Schlüssel usw.:

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

Hier verwenden wir SQLite als unsere Datenbank und speichern Sie sie in einer Datei. Natürlich können Sie auch andere Datenbanken (wie MySQL oder PostgreSQL) verwenden, indem Sie einfach die entsprechenden Datenbankverbindungsinformationen ändern.

Als nächstes müssen wir eine User- und eine Role-Klasse definieren. Hier verwenden wir SQLAlchemy als ORM-Bibliothek:

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'))

Hier definieren wir eine User-Klasse und eine Role-Klasse und verknüpfen sie jeweils mit der Tabelle user_roles. Wir definieren außerdem ein user_datastore-Objekt zum Verwalten von Benutzer- und Rolleninformationen.

Als nächstes müssen wir die Parameter und Klassen konfigurieren, die wir über die Security-Erweiterungsbibliothek definiert haben:

security = Security(app, user_datastore)

An diesem Punkt haben wir die Konfiguration von Flask-Security abgeschlossen. Als Nächstes können wir die Funktionen zur Benutzerauthentifizierung und Passwortverschlüsselung in unserer Flask-Anwendung verwenden.

Verwenden Sie Flask-Security zur Benutzerauthentifizierung und Passwortverschlüsselung

Bevor Sie Flask-Security verwenden, müssen wir einen neuen Flask-Blueprint erstellen und darin einige Ansichtsfunktionen definieren, um die Benutzeranmeldung, -registrierung, -abmeldung und andere Vorgänge zu verwalten:

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')

Hier definieren wir drei Ansichtsfunktionen: Anmelden, Abmelden und Registrieren. Die Anmeldefunktion wird zum Verarbeiten von Benutzeranmeldevorgängen verwendet, die Registrierungsfunktion wird zum Verarbeiten von Benutzerregistrierungsvorgängen verwendet und die Abmeldefunktion wird zum Verarbeiten von Benutzerabmeldevorgängen verwendet. Unter anderem verwenden wir die von Flask-Security bereitgestellten Funktionen login_user und logout_user, um Benutzeranmelde- und Abmeldefunktionen zu implementieren. In der Registerfunktion verwenden wir die Funktionen user_datastore.create_user und user_datastore.add_role_to_user, um einen neuen Benutzer zu erstellen und ihm eine Standardbenutzerrolle zuzuweisen.

Hier verwenden wir die Template-Engine von Flask, um HTML-Seiten zu rendern. Weitere Informationen finden Sie in der Dokumentation der Flask-Template-Engine.

Schließlich müssen wir diesen Entwurf in unserer Flask-Anwendung registrieren:

app.register_blueprint(security_blueprint)

An diesem Punkt sind wir mit der Verwendung von Flask-Security fertig. Jetzt können wir unsere Flask-Anwendung starten und über den Browser darauf zugreifen.

Zusammenfassung

In diesem Artikel haben wir beschrieben, wie Sie Flask-Security verwenden, um Benutzerauthentifizierungs- und Passwortverschlüsselungsfunktionen zu einer Python-Webanwendung hinzuzufügen. Durch das Studium dieses Artikels können wir die grundlegende Verwendung von Flask-Security verstehen und einige seiner Eigenschaften und Vorsichtsmaßnahmen verstehen. In tatsächlichen Anwendungen steht es uns frei, die Funktionalität von Flask-Security an unsere Bedürfnisse anzupassen und zu erweitern.

Das obige ist der detaillierte Inhalt vonFlask-Security: Hinzufügen von Benutzerauthentifizierung und Passwortverschlüsselung zu Python-Webanwendungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!