Flask-autentificering: En omfattende guide til at bygge sikre brugerloginsystemer

I nutidens digitale verden kræver næsten enhver meningsfuld webapplikation en måde at administrere og identificere sine brugere på. Uanset om du bygger et socialt netværk, en e-handelsplatform eller et virksomhedsintranet, er et sikkert og pålideligt autentificeringssystem ikke bare en funktion – det er et grundlæggende krav. Det er den digitale portvagt, der beskytter brugerdata, personaliserer oplevelser og skaber tillid.

Flask, det populære Python micro-framework, giver fleksibiliteten til at bygge kraftfulde webapplikationer, men overlader bevidst implementeringen af autentificering til udvikleren. Denne minimalistiske tilgang er en styrke, der giver dig mulighed for at vælge de bedste værktøjer til opgaven uden at være låst fast i en bestemt metode. Men det betyder også, at du er ansvarlig for at bygge systemet korrekt og sikkert.

Denne omfattende guide er designet til et internationalt publikum af udviklere. Vi vil guide dig gennem hvert trin i opbygningen af et komplet, produktionsklart brugerloginsystem i Flask. Vi starter med de absolutte grundlæggende principper og bygger gradvist op til en robust løsning, hvor vi dækker essentielle sikkerhedspraksisser undervejs. Ved slutningen af denne vejledning vil du have den viden og kode, der skal til for at implementere sikker brugerregistrering, login og sessionsstyring i dine egne Flask-projekter.

Forudsætninger: Opsætning af dit udviklingsmiljø

Før vi skriver vores første linje autentificeringskode, skal vi etablere et rent og organiseret udviklingsmiljø. Dette er en universel bedste praksis inden for softwareudvikling, der sikrer, at dit projekts afhængigheder ikke kommer i konflikt med andre projekter på dit system.

1. Python og virtuelle miljøer

Sørg for, at du har Python 3.6 eller nyere installeret på dit system. Vi vil bruge et virtuelt miljø til at isolere vores projekts pakker. Åbn din terminal eller kommandoprompt og kør følgende kommandoer:

            # Opret en projektmappe
mkdir flask-auth-project
cd flask-auth-project

# Opret et virtuelt miljø (mappen 'venv')
python3 -m venv venv

# Aktiver det virtuelle miljø
# På macOS/Linux:
source venv/bin/activate
# På Windows:
venv\Scripts\activate
            

              
                Copy
              
            
          

Du ved, at miljøet er aktivt, når du ser `(venv)` foran din kommandoprompt.

2. Installation af essentielle Flask-udvidelser

Vores autentificeringssystem vil blive bygget oven på en stak af fremragende, velvedligeholdte Flask-udvidelser. Hver tjener et specifikt formål:

• Flask: Det centrale web-framework.
• Flask-SQLAlchemy: En Object-Relational Mapper (ORM) til at interagere med vores database på en Pythonisk måde.
• Flask-Migrate: Håndterer databaseskema-migrationer.
• Flask-WTF: Forenkler arbejdet med webformularer og tilbyder validering og CSRF-beskyttelse.
• Flask-Login: Administrerer brugersessionen, håndterer login, logout og husker brugere.
• Flask-Bcrypt: Tilbyder stærke password-hashing-funktioner.
• python-dotenv: Administrerer miljøvariabler til konfiguration.

Installer dem alle med en enkelt kommando:

            pip install Flask Flask-SQLAlchemy Flask-Migrate Flask-WTF Flask-Login Flask-Bcrypt python-dotenv
            

              
                Copy
              
            
          

Del 1: Fundamentet - Projektstruktur og databasemodel

Et velorganiseret projekt er lettere at vedligeholde, skalere og forstå. Vi vil bruge et almindeligt Flask application factory pattern.

Design af en skalerbar projektstruktur

Opret følgende mappe- og filstruktur inde i din `flask-auth-project`-mappe:

            /flask-auth-project
|-- /app
|   |-- /static
|   |-- /templates
|   |   |-- base.html
|   |   |-- index.html
|   |   |-- login.html
|   |   |-- register.html
|   |   |-- dashboard.html
|   |-- __init__.py
|   |-- models.py
|   |-- forms.py
|   |-- routes.py
|-- .env
|-- config.py
|-- run.py
            

              
                Copy
              
            
          

• /app: Hovedpakken, der indeholder vores applikationslogik.
• /templates: Vil indeholde vores HTML-filer.
• __init__.py: Initialiserer vores Flask-applikation (the application factory).
• models.py: Definerer vores databasetabeller (f.eks. User-modellen).
• forms.py: Definerer vores registrerings- og loginformularer ved hjælp af Flask-WTF.
• routes.py: Indeholder vores view-funktioner (logikken for forskellige URL'er).
• config.py: Gemmer applikationens konfigurationsindstillinger.
• run.py: Hovedscriptet til at starte webserveren.
• .env: En fil til at gemme miljøvariabler som hemmelige nøgler (denne fil bør IKKE committes til versionskontrol).

Konfiguration af din Flask-applikation

Lad os udfylde vores konfigurationsfiler.

.env-fil:

Opret denne fil i roden af dit projekt. Det er her, vi gemmer følsomme oplysninger.

            SECRET_KEY='en-meget-staerk-og-lang-tilfaeldig-hemmelig-noegle'
DATABASE_URL='sqlite:///site.db'
            

              
                Copy
              
            
          

VIGTIGT: Erstat `SECRET_KEY`-værdien med din egen lange, tilfældige og uforudsigelige streng. Denne nøgle er afgørende for at sikre brugersessioner.

config.py-fil:

Denne fil læser konfigurationen fra vores `.env`-fil.

            import os
from dotenv import load_dotenv

basedir = os.path.abspath(os.path.dirname(__file__))
load_dotenv(os.path.join(basedir, '.env'))

class Config:
    SECRET_KEY = os.environ.get('SECRET_KEY')
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \
        'sqlite:///' + os.path.join(basedir, 'app.db')
    SQLALCHEMY_TRACK_MODIFICATIONS = False
            

              
                Copy
              
            
          

Oprettelse af User-modellen med Flask-SQLAlchemy

User-modellen er hjertet i vores autentificeringssystem. Den definerer strukturen af `users`-tabellen i vores database.

app/models.py:

            from flask_login import UserMixin
from . import db, login_manager

@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))

class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password_hash = db.Column(db.String(128), nullable=False)

    def __repr__(self):
        return f''
            

              
                Copy
              
            
          

Lad os bryde det ned:

• `UserMixin`: Dette er en klasse fra `Flask-Login`, der inkluderer generiske implementeringer for metoder som `is_authenticated`, `is_active`, osv., som vores User-model har brug for.
• `@login_manager.user_loader`: Denne funktion er et krav for `Flask-Login`. Den bruges til at genindlæse brugerobjektet fra det bruger-ID, der er gemt i sessionen. Flask-Login vil kalde denne funktion ved hver anmodning for en logget ind bruger.
• `password_hash`: Bemærk, at vi IKKE gemmer adgangskoden direkte. Vi gemmer en `password_hash`. Dette er et af de mest kritiske sikkerhedsprincipper inden for autentificering. At gemme adgangskoder i klartekst er en massiv sikkerhedsrisiko. Hvis din database nogensinde bliver kompromitteret, vil angribere have alle brugeres adgangskoder. Ved at gemme en hash gør du det beregningsmæssigt umuligt for dem at genskabe de originale adgangskoder.

Initialisering af applikationen

Lad os nu binde det hele sammen i vores application factory.

app/__init__.py:

            from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from flask_login import LoginManager
from config import Config

db = SQLAlchemy()
bcrypt = Bcrypt()
login_manager = LoginManager()
login_manager.login_view = 'main.login' # Omdirigeringsside for brugere, der ikke er logget ind
login_manager.login_message_category = 'info' # Bootstrap-klasse for meddelelser

def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)

    db.init_app(app)
    bcrypt.init_app(app)
    login_manager.init_app(app)

    from .routes import main as main_blueprint
    app.register_blueprint(main_blueprint)

    return app
            

              
                Copy
              
            
          

run.py:

            from app import create_app, db
from app.models import User

app = create_app()

@app.shell_context_processor
def make_shell_context():
    return {'db': db, 'User': User}

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

              
                Copy
              
            
          

Før vi kan køre appen, skal vi oprette databasen. Kør disse kommandoer fra dit aktiverede virtuelle miljø i terminalen:

            flask shell
>>> from app import db
>>> db.create_all()
>>> exit()
            

              
                Copy
              
            
          

Dette vil oprette en `site.db`-fil i din rodmappe, som indeholder `user`-tabellen, vi har defineret.

Del 2: Opbygning af kerneautentificeringslogikken

Med fundamentet på plads kan vi nu bygge de brugerorienterede dele: registrerings- og loginformularer og de ruter, der behandler dem.

Brugerregistrering: Sikker oprettelse af nye brugere

Først definerer vi formularen ved hjælp af Flask-WTF.

app/forms.py:

            from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField, BooleanField
from wtforms.validators import DataRequired, Length, Email, EqualTo, ValidationError
from .models import User

class RegistrationForm(FlaskForm):
    username = StringField('Brugernavn',
                           validators=[DataRequired(), Length(min=2, max=20)])
    email = StringField('Email',
                        validators=[DataRequired(), Email()])
    password = PasswordField('Adgangskode', validators=[DataRequired()])
    confirm_password = PasswordField('Bekræft adgangskode',
                                     validators=[DataRequired(), EqualTo('password')])
    submit = SubmitField('Opret bruger')

    def validate_username(self, username):
        user = User.query.filter_by(username=username.data).first()
        if user:
            raise ValidationError('Dette brugernavn er taget. Vælg venligst et andet.')

    def validate_email(self, email):
        user = User.query.filter_by(email=email.data).first()
        if user:
            raise ValidationError('Denne email er allerede registreret. Vælg venligst en anden.')

class LoginForm(FlaskForm):
    email = StringField('Email',
                        validators=[DataRequired(), Email()])
    password = PasswordField('Adgangskode', validators=[DataRequired()])
    remember = BooleanField('Husk mig')
    submit = SubmitField('Login')
            

              
                Copy
              
            
          

Bemærk de brugerdefinerede validatorer `validate_username` og `validate_email`. Flask-WTF kalder automatisk enhver metode med mønsteret `validate_` og bruger den som en brugerdefineret validator for det pågældende felt. Sådan tjekker vi, om et brugernavn eller en e-mail allerede findes i databasen.

Dernæst opretter vi ruten til at håndtere registrering.

app/routes.py:

            from flask import Blueprint, render_template, url_for, flash, redirect, request
from .forms import RegistrationForm, LoginForm
from .models import User
from . import db, bcrypt
from flask_login import login_user, current_user, logout_user, login_required

main = Blueprint('main', __name__)

@main.route('/')
@main.route('/index')
def index():
    return render_template('index.html')

@main.route('/register', methods=['GET', 'POST'])
def register():
    if current_user.is_authenticated:
        return redirect(url_for('main.index'))
    form = RegistrationForm()
    if form.validate_on_submit():
        hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')
        user = User(username=form.username.data, email=form.email.data, password_hash=hashed_password)
        db.session.add(user)
        db.session.commit()
        flash('Din konto er blevet oprettet! Du kan nu logge ind', 'success')
        return redirect(url_for('main.login'))
    return render_template('register.html', title='Registrer', form=form)
            

              
                Copy
              
            
          

Password-hashing med Flask-Bcrypt

Den vigtigste linje i koden ovenfor er:

hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')

Bcrypt er en moderne, adaptiv hashing-algoritme. Den tager brugerens adgangskode og udfører en kompleks, beregningsmæssigt dyr envejs-transformation på den. Den inkorporerer også en tilfældig "salt" for hver adgangskode for at forhindre rainbow table-angreb. Det betyder, at selv hvis to brugere har den samme adgangskode, vil deres gemte hashes være helt forskellige. Den resulterende hash er det, vi gemmer i databasen. Det er praktisk talt umuligt at vende denne proces for at få den originale adgangskode.

Brugerlogin: Autentificering af eksisterende brugere

Lad os nu tilføje login-ruten til vores `app/routes.py`-fil.

app/routes.py (tilføj denne rute):

            @main.route('/login', methods=['GET', 'POST'])
def login():
    if current_user.is_authenticated:
        return redirect(url_for('main.index'))
    form = LoginForm()
    if form.validate_on_submit():
        user = User.query.filter_by(email=form.email.data).first()
        if user and bcrypt.check_password_hash(user.password_hash, form.password.data):
            login_user(user, remember=form.remember.data)
            next_page = request.args.get('next')
            return redirect(next_page) if next_page else redirect(url_for('main.index'))
        else:
            flash('Login mislykkedes. Tjek venligst email og adgangskode', 'danger')
    return render_template('login.html', title='Login', form=form)
            

              
                Copy
              
            
          

De vigtigste trin her er:

1. Find brugeren: Vi forespørger databasen efter en bruger med den indsendte e-mailadresse.
2. Bekræft adgangskoden: Dette er det afgørende tjek: `bcrypt.check_password_hash(user.password_hash, form.password.data)`. Denne funktion tager den gemte hash fra vores database og den klartekst-adgangskode, brugeren lige har indtastet. Den re-hasher den indsendte adgangskode ved hjælp af den samme salt (som er gemt som en del af selve hashen) og sammenligner resultaterne. Den returnerer `True` kun, hvis de matcher. Dette giver os mulighed for at bekræfte en adgangskode uden nogensinde at skulle dekryptere den gemte hash.
3. Administrer sessionen: Hvis adgangskoden er korrekt, kalder vi `login_user(user, remember=form.remember.data)`. Denne funktion fra `Flask-Login` registrerer brugeren som logget ind og gemmer deres ID i brugersessionen (en sikker, server-side cookie). `remember`-argumentet håndterer "Husk mig"-funktionaliteten.

Bruger-logout: Sikker afslutning af en session

Logout er ligetil. Vi har bare brug for en rute, der kalder `Flask-Login`'s `logout_user`-funktion.

app/routes.py (tilføj denne rute):

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

              
                Copy
              
            
          

Denne funktion vil fjerne brugerens ID fra sessionen og dermed effektivt logge dem ud.

Del 3: Beskyttelse af ruter og håndtering af brugersessioner

Nu hvor brugere kan logge ind og ud, skal vi gøre brug af deres autentificerede tilstand.

Beskyttelse af indhold med `@login_required`

Mange sider, som f.eks. en brugers dashboard eller kontoindstillinger, bør kun være tilgængelige for brugere, der er logget ind. `Flask-Login` gør dette utroligt simpelt med `@login_required`-dekoratoren.

Lad os oprette en beskyttet dashboard-rute.

app/routes.py (tilføj denne rute):

            @main.route('/dashboard')
@login_required
def dashboard():
    return render_template('dashboard.html', title='Dashboard')
            

              
                Copy
              
            
          

Det er det! Hvis en bruger, der ikke er logget ind, forsøger at besøge `/dashboard`, vil `Flask-Login` automatisk opsnappe anmodningen og omdirigere dem til login-siden (som vi konfigurerede i `app/__init__.py` med `login_manager.login_view = 'main.login'`). Når de er logget succesfuldt ind, vil den intelligent omdirigere dem tilbage til den dashboard-side, de oprindeligt forsøgte at få adgang til.

Adgang til den aktuelle brugers oplysninger

Inden for dine ruter og skabeloner giver `Flask-Login` et magisk proxy-objekt kaldet `current_user`. Dette objekt repræsenterer den bruger, der i øjeblikket er logget ind for den aktive anmodning. Hvis ingen bruger er logget ind, er det et anonymt brugerobjekt, hvor `current_user.is_authenticated` vil være `False`.

Du kan bruge dette i din Python-kode:

            # I en rute
if current_user.is_authenticated:
    print(f'Hej, {current_user.username}!')
            

              
                Copy
              
            
          

Og du kan også bruge det direkte i dine Jinja2-skabeloner:

            <!-- I en skabelon som base.html -->
{% if current_user.is_authenticated %}
    <a href="{{ url_for('main.dashboard') }}">Dashboard</a>
    <a href="{{ url_for('main.logout') }}">Log ud</a>
{% else %}
    <a href="{{ url_for('main.login') }}">Login</a>
    <a href="{{ url_for('main.register') }}">Registrer</a>
{% endif %}
            

              
                Copy
              
            
          

Dette giver dig mulighed for dynamisk at ændre navigationslinjen eller andre dele af din brugergrænseflade baseret på brugerens login-status.

HTML-skabeloner

For fuldstændighedens skyld er her nogle grundlæggende skabeloner, du kan placere i `app/templates`-mappen. De bruger simpel HTML, men kan let integreres med et framework som Bootstrap eller Tailwind CSS.

base.html:

            <!DOCTYPE html>
<html lang="da">
<head>
    <meta charset="UTF-8">
    <title>{{ title }} - Flask Auth App</title>
</head>
<body>
    <nav>
        <a href="{{ url_for('main.index') }}">Hjem</a>
        {% if current_user.is_authenticated %}
            <a href="{{ url_for('main.dashboard') }}">Dashboard</a>
            <a href="{{ url_for('main.logout') }}">Log ud</a>
        {% else %}
            <a href="{{ url_for('main.login') }}">Login</a>
            <a href="{{ url_for('main.register') }}">Registrer</a>
        {% endif %}
    </nav>
    <hr>
    {% with messages = get_flashed_messages(with_categories=true) %}
        {% if messages %}
            {% for category, message in messages %}
                <div class="alert-{{ category }}">{{ message }}</div>
            {% endfor %}
        {% endif %}
    {% endwith %}
    {% block content %}{% endblock %}
</body>
</html>
            

              
                Copy
              
            
          

register.html / login.html (eksempel med registreringsformular):

            {% extends "base.html" %}
{% block content %}
    <div>
        <form method="POST" action="">
            {{ form.hidden_tag() }}
            <fieldset>
                <legend>Tilmeld dig i dag</legend>
                <div>
                    {{ form.username.label }}
                    {{ form.username() }}
                </div>
                <div>
                    {{ form.email.label }}
                    {{ form.email() }}
                </div>
                <div>
                    {{ form.password.label }}
                    {{ form.password() }}
                </div>
                <div>
                    {{ form.confirm_password.label }}
                    {{ form.confirm_password() }}
                </div>
            </fieldset>
            <div>
                {{ form.submit() }}
            </div>
        </form>
    </div>
{% endblock content %}
            

              
                Copy
              
            
          

Del 4: Avancerede emner og bedste sikkerhedspraksis

Systemet, vi har bygget, er solidt, men en produktionsklar applikation kræver mere. Her er essentielle næste skridt og sikkerhedsovervejelser.

1. Funktionalitet til nulstilling af adgangskode

Brugere vil uundgåeligt glemme deres adgangskoder. En sikker proces til nulstilling af adgangskode er afgørende. Den standardiserede, sikre proces er:

1. Brugeren indtaster sin e-mailadresse på en "Glemt adgangskode"-side.
2. Applikationen genererer en sikker, engangsbrugs, tidsfølsom token. `itsdangerous`-biblioteket (installeret med Flask) er perfekt til dette.
3. Applikationen sender en e-mail til brugeren med et link, der indeholder denne token.
4. Når brugeren klikker på linket, validerer applikationen tokenen (tjekker dens gyldighed og udløb).
5. Hvis den er gyldig, præsenteres brugeren for en formular til at indtaste og bekræfte en ny adgangskode.

Send aldrig en brugers gamle adgangskode eller en ny adgangskode i klartekst via e-mail.

2. E-mail-bekræftelse ved registrering

For at forhindre brugere i at tilmelde sig med falske e-mailadresser og for at sikre, at du kan kontakte dem, bør du implementere et e-mail-bekræftelsestrin. Processen ligner meget en nulstilling af adgangskode: generer en token, send et bekræftelseslink via e-mail, og hav en rute, der validerer tokenen og markerer brugerens konto som `confirmed` i databasen.

3. Rate Limiting for at forhindre brute-force-angreb

Et brute-force-angreb er, når en angriber gentagne gange prøver forskellige adgangskoder på en login-formular. For at imødegå dette bør du implementere hastighedsbegrænsning (rate limiting). Dette begrænser antallet af loginforsøg, en enkelt IP-adresse kan foretage inden for en bestemt tidsramme (f.eks. 5 mislykkede forsøg pr. minut). `Flask-Limiter`-udvidelsen er et fremragende værktøj til dette.

4. Brug af miljøvariabler til alle hemmeligheder

Vi har allerede gjort dette for vores `SECRET_KEY` og `DATABASE_URL`, hvilket er fantastisk. Det er en kritisk praksis for sikkerhed og portabilitet. Commit aldrig din `.env`-fil eller nogen fil med hardkodede legitimationsoplysninger (som API-nøgler eller databaseadgangskoder) til et offentligt versionskontrolsystem som GitHub. Brug altid en `.gitignore`-fil til at udelukke dem.

5. Beskyttelse mod Cross-Site Request Forgery (CSRF)

Gode nyheder! Ved at bruge `Flask-WTF` og inkludere `{{ form.hidden_tag() }}` i vores formularer har vi allerede aktiveret CSRF-beskyttelse. Denne skjulte tag genererer en unik token for hver formularindsendelse, hvilket sikrer, at anmodningen kommer fra din faktiske side og ikke fra en ondsindet ekstern kilde, der forsøger at narre dine brugere.

Konklusion: Dine næste skridt inden for Flask-autentificering

Tillykke! Du har med succes bygget et komplet og sikkert brugerautentificeringssystem i Flask. Vi har dækket hele livscyklussen: opsætning af et skalerbart projekt, oprettelse af en databasemodel, sikker håndtering af brugerregistrering med password-hashing, autentificering af brugere, administration af sessioner med Flask-Login og beskyttelse af ruter.

Du har nu et robust fundament, som du trygt kan integrere i ethvert Flask-projekt. Husk, at sikkerhed er en løbende proces, ikke en engangsopsætning. De principper, vi har diskuteret – især hashing af adgangskoder og beskyttelse af hemmelige nøgler – er ikke til forhandling for nogen applikation, der håndterer brugerdata.

Herfra kan du udforske endnu mere avancerede autentificeringsemner for yderligere at forbedre din applikation:

• Rollebaseret adgangskontrol (RBAC): Tilføj et `role`-felt til din User-model for at give forskellige tilladelser til almindelige brugere og administratorer.
• OAuth-integration: Tillad brugere at logge ind ved hjælp af tredjepartstjenester som Google, GitHub eller Facebook.
• To-faktor-autentificering (2FA): Tilføj et ekstra sikkerhedslag ved at kræve en kode fra en autentificeringsapp eller SMS.

Ved at mestre de grundlæggende principper for autentificering har du taget et betydeligt skridt fremad på din rejse som professionel webudvikler. God kodning!