Flask Authentication

6 Kernkonzepte

Die wichtigsten Methoden für Benutzerauthentifizierung in Flask: Session · Flask-Login · JWT · Passwort-Hashing · Decorators · Protected Routes Authentifizierung ist ein zentraler Bestandteil jeder Webanwendung. Diese Cheatsheet zeigt die gängigsten Methoden – von einfachen Session-basierten Lösungen bis hin zu JWT für APIs.

Session-basierte Auth – Einfach & integriert

session · login_user · logout_user

# Login session['user_id'] = user.id session.permanent = True # Logout session.pop('user_id', None)

Session-basierte Authentifizierung ist der einfachste Weg, Benutzer in Flask zu authentifizieren. Die Benutzer-ID wird in der Session gespeichert, die als signiertes Cookie beim Client hinterlegt wird.

Beispiele

from flask import Flask, session, redirect, url_for

# Login

@app.route('/login', methods=['POST'])

def login():

user = User.query.filter_by(email=request.form['email']).first()

if user and check_password(user.password, request.form['password']):

session['user_id'] = user.id

session.permanent = True

return redirect(url_for('dashboard'))

return 'Ungültige Anmeldedaten', 401

# Prüfen, ob Benutzer eingeloggt ist

def current_user():

user_id = session.get('user_id')

if user_id:

return User.query.get(user_id)

return None

# Logout

@app.route('/logout')

def logout():

session.pop('user_id', None)

return redirect(url_for('home'))

Tipp: Setzen Sie session.permanent = True und konfigurieren Sie PERMANENT_SESSION_LIFETIME (z.B. timedelta(days=7)) für langlebige Sessions.

Flask-Login – Professionelle Session-Verwaltung

LoginManager · login_user · current_user · login_required

# Setup from flask_login import LoginManager, login_user, logout_user, current_user, login_required login_manager = LoginManager() login_manager.init_app(app)

Flask-Login ist die Standard-Erweiterung für Session-basierte Authentifizierung. Sie bietet praktische Hilfsfunktionen wie login_user, current_user und den @login_required-Decorator.

Beispiele

from flask_login import LoginManager, UserMixin, login_user, logout_user, current_user, login_required

# User-Klasse (muss UserMixin erben)

class User(UserMixin):

def __init__(self, id, email, password):

self.id = id

self.email = email

self.password = password

# LoginManager konfigurieren

login_manager = LoginManager()

login_manager.init_app(app)

login_manager.login_view = 'login' # Route für Login-Seite

# User-Loader

@login_manager.user_loader

def load_user(user_id):

return User.query.get(user_id)

# Login

@app.route('/login', methods=['POST'])

def login():

user = User.query.filter_by(email=request.form['email']).first()

if user and check_password(user.password, request.form['password']):

login_user(user, remember=True)

return redirect(url_for('dashboard'))

return 'Ungültige Anmeldedaten', 401

# Geschützte Route

@app.route('/dashboard')

@login_required

def dashboard():

return f'Willkommen, {current_user.email}!'

# Logout

@app.route('/logout')

@login_required

def logout():

logout_user()

return redirect(url_for('home'))

Tipp: login_user(user, remember=True) setzt ein langlebiges Cookie für "Angemeldet bleiben". current_user ist in jedem Request verfügbar.

JWT – Authentifizierung für APIs

PyJWT · Flask-JWT-Extended · token · @jwt_required

# Token erstellen import jwt token = jwt.encode({'user_id': user.id}, app.config['SECRET_KEY'], algorithm='HS256') # Token verifizieren payload = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])

JWT (JSON Web Tokens) sind der Standard für API-Authentifizierung. Der Client sendet bei jedem Request das Token im Authorization-Header. Flask-JWT-Extended vereinfacht die Implementierung.

Beispiele

from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity

# Setup

jwt = JWTManager()

jwt.init_app(app)

# Login-Endpoint – Token erstellen

@app.route('/auth/login', methods=['POST'])

def login():

email = request.json.get('email')

user = User.query.filter_by(email=email).first()

if user and verify_password(user.password_hash, request.json.get('password')):

access_token = create_access_token(identity=user.id)

return {'access_token': access_token}

return {'message': 'Ungültige Anmeldedaten'}, 401

# Geschützter API-Endpoint

@app.route('/api/profile', methods=['GET'])

@jwt_required()

def profile():

user_id = get_jwt_identity()

user = User.query.get(user_id)

return {'id': user.id, 'email': user.email}

# Token aktualisieren (Refresh-Token)

@app.route('/auth/refresh', methods=['POST'])

@jwt_required(refresh=True)

def refresh():

user_id = get_jwt_identity()

return {'access_token': create_access_token(identity=user_id)}

Tipp: Für API-Authentifizierung verwenden Sie @jwt_required() und get_jwt_identity(). Der Client sendet das Token im Authorization: Bearer <token>-Header.

Passwort-Hashing – bcrypt & werkzeug

bcrypt · generate_password_hash · check_password_hash

# Mit werkzeug.security from werkzeug.security import generate_password_hash, check_password_hash hash = generate_password_hash('mein_passwort') is_valid = check_password_hash(hash, 'mein_passwort')

Passwort-Hashing ist essenziell für die sichere Speicherung von Benutzerpasswörtern. bcrypt und werkzeug.security bieten einfache und sichere Hashing-Funktionen.

Beispiele

# Mit werkzeug.security (empfohlen)

from werkzeug.security import generate_password_hash, check_password_hash

# Passwort hashen (User-Erstellung)

password_hash = generate_password_hash('mein_sicheres_passwort')

# Mit bcrypt (alternative)

import bcrypt

salt = bcrypt.gensalt()

hash = bcrypt.hashpw(b'mein_passwort', salt)

is_valid = bcrypt.checkpw(b'mein_passwort', hash)

# User-Modell mit Passwort-Hashing

class User(db.Model):

id = db.Column(db.Integer, primary_key=True)

email = db.Column(db.String(100), unique=True)

password_hash = db.Column(db.String(128))

def set_password(self, password):

self.password_hash = generate_password_hash(password)

def check_password(self, password):

return check_password_hash(self.password_hash, password)

# Registrierung

@app.route('/register', methods=['POST'])

def register():

user = User(email=request.form['email'])

user.set_password(request.form['password'])

db.session.add(user)

db.session.commit()

return redirect(url_for('login'))

⚠️ Sicherheitshinweis: Speichern Sie niemals Passwörter im Klartext! Verwenden Sie immer ein sicheres Hashing-Verfahren wie bcrypt oder werkzeug.security. werkzeug.security verwendet standardmäßig PBKDF2 mit SHA-256.

Custom Decorators – Berechtigungen prüfen

@role_required · @permission_required

# Custom Decorator für Rollen def role_required(role): def decorator(f): @wraps(f) def wrapped(*args, **kwargs): # Berechtigungsprüfung return f(*args, **kwargs) return wrapped return decorator

Custom Decorators ermöglichen die einfache und wiederverwendbare Prüfung von Benutzerberechtigungen – z.B. für Rollen (Admin, Moderator) oder spezifische Berechtigungen.

Beispiele

from functools import wraps

from flask import abort, session

# Role-Required Decorator

def role_required(required_role):

def decorator(f):

@wraps(f)

def wrapped(*args, **kwargs):

# Aktuellen Benutzer aus Session oder Flask-Login holen

user = current_user()

if not user or user.role != required_role:

abort(403)

return f(*args, **kwargs)

return wrapped

return decorator

# Verwendung

@app.route('/admin')

@role_required('admin')

def admin_panel():

return 'Admin-Bereich'

# Mehrere Rollen erlauben

def roles_required(*roles):

def decorator(f):

@wraps(f)

def wrapped(*args, **kwargs):

user = current_user()

if not user or user.role not in roles:

abort(403)

return f(*args, **kwargs)

return wrapped

return decorator

# Verwendung mit mehreren Rollen

@roles_required('admin', 'moderator')

def moderator_panel():

return 'Moderator-Bereich'

Tipp: Kombinieren Sie Custom Decorators mit Flask-Login's @login_required für eine mehrschichtige Berechtigungsprüfung. Verwenden Sie abort(403) für unberechtigte Zugriffe.

Protected Routes – Routen absichern

@login_required · @jwt_required · @role_required

# Mit Flask-Login @app.route('/dashboard') @login_required def dashboard(): return f'Hallo, {current_user.email}!'

Protected Routes sind Seiten oder Endpoints, die nur für authentifizierte Benutzer zugänglich sind. Sie werden mit Decorators wie @login_required oder @jwt_required abgesichert.

Beispiele

# Kombinierte Decorators

@app.route('/settings')

@login_required

@role_required('admin')

def settings():

return 'Einstellungen (Admin)'

# User-Profile (nur für den eigenen User)

@app.route('/user/<int:user_id>')

@login_required

def user_profile(user_id):

if current_user.id != user_id and current_user.role != 'admin':

abort(403)

user = User.query.get(user_id)

return render_template('profile.html', user=user)

# API mit JWT

@app.route('/api/orders', methods=['GET'])

@jwt_required()

def get_orders():

user_id = get_jwt_identity()

orders = Order.query.filter_by(user_id=user_id).all()

return {'orders': [order.to_dict() for order in orders]}

Tipp: Verwenden Sie abort(401) für nicht authentifizierte und abort(403) für nicht autorisierte Zugriffe. Flask-Login leitet automatisch zur Login-Seite weiter (login_view).

Flask Authentication im Überblick

Session Einfache Cookie-basierte Auth
session['user_id']

Flask-Login Professionelle Session-Auth
@login_required, current_user

JWT Token-basierte API-Auth
@jwt_required

bcrypt Passwort-Hashing
Sichere Speicherung

Decorator Berechtigungen prüfen
@role_required

Protected Geschützte Routen
Login erforderlich

Quick Summary

session

Session-Auth

Flask-Login

Professionelle Auth

JWT

API-Auth

bcrypt

Passwort-Hashing

@decorator

Berechtigungen

@login_required

Geschützte Routen

login_user(user) · @login_required · create_access_token(identity=user.id)