Flask-autentisering: En omfattende guide til å bygge sikre brukerpåloggingssystemer

I dagens digitale verden krever nesten hver eneste meningsfulle nettapplikasjon en måte å administrere og identifisere brukerne sine på. Enten du bygger et sosialt nettverk, en e-handelsplattform eller et bedriftsintranett, er et sikkert og pålitelig autentiseringssystem ikke bare en funksjon – det er et grunnleggende krav. Det er den digitale portvakten som beskytter brukerdata, personaliserer opplevelser og muliggjør tillit.

Flask, det populære Python-mikrorammeverket, gir fleksibiliteten til å bygge kraftige nettapplikasjoner, men overlater bevisst autentiseringsimplementeringen til utvikleren. Denne minimalistiske tilnærmingen er en styrke, da den lar deg velge de beste verktøyene for jobben uten å være låst til en spesifikk metodikk. Imidlertid betyr det også at du er ansvarlig for å bygge systemet korrekt og sikkert.

Denne omfattende guiden er designet for et internasjonalt publikum av utviklere. Vi vil lede deg gjennom hvert trinn i å bygge et komplett, produksjonsklart brukerpåloggingssystem i Flask. Vi starter med det helt grunnleggende og bygger gradvis opp til en robust løsning, og dekker essensielle sikkerhetspraksiser underveis. Ved slutten av denne veiledningen vil du ha kunnskapen og koden for å implementere sikker brukerregistrering, pålogging og sesjonshåndtering i dine egne Flask-prosjekter.

Forutsetninger: Sette opp utviklingsmiljøet ditt

Før vi skriver vår første linje med autentiseringskode, må vi etablere et rent og organisert utviklingsmiljø. Dette er en universell beste praksis innen programvareutvikling, og sikrer at prosjektets avhengigheter ikke kolliderer med andre prosjekter på systemet ditt.

1. Python og virtuelle miljøer

Sørg for at du har Python 3.6 eller nyere installert på systemet ditt. Vi vil bruke et virtuelt miljø for å isolere prosjektets pakker. Åpne terminalen eller kommandolinjen og kjør følgende kommandoer:

            # Create a project directory
mkdir flask-auth-project
cd flask-auth-project

# Create a virtual environment (the 'venv' folder)
python3 -m venv venv

# Activate the virtual environment
# On macOS/Linux:
source venv/bin/activate
# On Windows:
venv\Scripts\activate
            

              
                Copy
              
            
          

Du vil vite at miljøet er aktivt når du ser `(venv)` foran kommandolinjen din.

2. Installere essensielle Flask-utvidelser

Vårt autentiseringssystem vil bli bygget på en rekke utmerkede, godt vedlikeholdte Flask-utvidelser. Hver tjener et spesifikt formål:

• Flask: Kjerne-webrammeverket.
• Flask-SQLAlchemy: En Object-Relational Mapper (ORM) for å interagere med databasen vår på en Python-vennlig måte.
• Flask-Migrate: Håndterer databaseskjema-migreringer.
• Flask-WTF: Forenkler arbeidet med nettskjemaer, og gir validering og CSRF-beskyttelse.
• Flask-Login: Håndterer brukersesjonen, og tar seg av pålogging, utlogging og husker brukere.
• Flask-Bcrypt: Gir sterke passordhashing-funksjoner.
• python-dotenv: Håndterer miljøvariabler for konfigurasjon.

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 - Prosjektstruktur og databasemodell

Et godt organisert prosjekt er lettere å vedlikeholde, skalere og forstå. Vi vil bruke et vanlig Flask-applikasjonsfabrikkmønster.

Design av en skalerbar prosjektstruktur

Opprett følgende katalog- og filstruktur inne i `flask-auth-project`-katalogen din:

            /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 som inneholder applikasjonslogikken vår.
• /templates: Vil inneholde våre HTML-filer.
• __init__.py: Initialiserer vår Flask-applikasjon (applikasjonsfabrikken).
• models.py: Definerer databasetabellene våre (f.eks. User-modellen).
• forms.py: Definerer registrerings- og påloggingsskjemaene våre ved hjelp av Flask-WTF.
• routes.py: Inneholder våre visningsfunksjoner (logikken for forskjellige URL-er).
• config.py: Lagrer applikasjonskonfigurasjonsinnstillinger.
• run.py: Hovedskriptet for å starte webserveren.
• .env: En fil for å lagre miljøvariabler som hemmelige nøkler (denne filen skal IKKE lastes opp til versjonskontroll).

Konfigurere din Flask-applikasjon

La oss fylle ut konfigurasjonsfilene våre.

.env-fil:

Opprett denne filen i roten av prosjektet ditt. Dette er hvor vi vil lagre sensitiv informasjon.

            SECRET_KEY='a-very-strong-and-long-random-secret-key'
DATABASE_URL='sqlite:///site.db'
            

              
                Copy
              
            
          

VIKTIG: Erstatt `SECRET_KEY`-verdien med din egen lange, tilfeldige og uforutsigbare streng. Denne nøkkelen er avgjørende for å sikre brukersesjoner.

config.py-fil:

Denne filen leser konfigurasjonen fra vår `.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
              
            
          

Opprette brukermodellen med Flask-SQLAlchemy

Brukermodellen er hjertet i autentiseringssystemet vårt. Den definerer strukturen til `users`-tabellen i databasen vår.

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
              
            
          

La oss bryte dette ned:

• `UserMixin`: Dette er en klasse fra `Flask-Login` som inkluderer generiske implementeringer for metoder som `is_authenticated`, `is_active`, etc., som vår User-modell trenger.
• `@login_manager.user_loader`: Denne funksjonen er et krav for `Flask-Login`. Den brukes til å laste inn brukerobjektet på nytt fra bruker-ID-en som er lagret i sesjonen. Flask-Login vil kalle denne funksjonen på hver forespørsel for en pålogget bruker.
• `password_hash`: Legg merke til at vi IKKE lagrer passordet direkte. Vi lagrer en `password_hash`. Dette er et av de mest kritiske sikkerhetsprinsippene i autentisering. Å lagre passord i ren tekst er en massiv sikkerhetssårbarhet. Hvis databasen din noen gang blir kompromittert, vil angripere ha alle brukernes passord. Ved å lagre en hash gjør du det beregningsmessig umulig for dem å hente de originale passordene.

Initialisere applikasjonen

Nå, la oss binde alt sammen i applikasjonsfabrikken vår.

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' # Redirect page for users not logged in
login_manager.login_message_category = 'info' # Bootstrap class for messages

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 kjøre appen, må vi opprette databasen. Fra ditt aktiverte virtuelle miljø i terminalen, kjør disse kommandoene:

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

              
                Copy
              
            
          

Dette vil opprette en `site.db`-fil i rotkatalogen din, som inneholder `user`-tabellen vi definerte.

Del 2: Bygge kjerneautentiseringslogikken

Med grunnlaget på plass kan vi nå bygge de brukerrettede delene: registrerings- og påloggingsskjemaer og rutene som behandler dem.

Brukerregistrering: Sikker registrering av nye brukere

Først definerer vi skjemaet ved hjelp av 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('Brukernavn',
                           validators=[DataRequired(), Length(min=2, max=20)])
    email = StringField('E-post',
                        validators=[DataRequired(), Email()])
    password = PasswordField('Passord', validators=[DataRequired()])
    confirm_password = PasswordField('Bekreft passord',
                                     validators=[DataRequired(), EqualTo('password')])
    submit = SubmitField('Registrer deg')

    def validate_username(self, username):
        user = User.query.filter_by(username=username.data).first()
        if user:
            raise ValidationError('Det brukernavnet er allerede tatt. Vennligst velg et annet.')

    def validate_email(self, email):
        user = User.query.filter_by(email=email.data).first()
        if user:
            raise ValidationError('Den e-postadressen er allerede registrert. Vennligst velg en annen.')

class LoginForm(FlaskForm):
    email = StringField('E-post',
                        validators=[DataRequired(), Email()])
    password = PasswordField('Passord', validators=[DataRequired()])
    remember = BooleanField('Husk meg')
    submit = SubmitField('Logg inn')
            

              
                Copy
              
            
          

Legg merke til de tilpassede validatorene `validate_username` og `validate_email`. Flask-WTF kaller automatisk enhver metode med mønsteret `validate_` og bruker den som en tilpasset validator for det feltet. Dette er hvordan vi sjekker om et brukernavn eller en e-post allerede er i databasen.

Deretter oppretter vi ruten for å 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('Kontoen din er opprettet! Du kan nå logge inn', 'success')
        return redirect(url_for('main.login'))
    return render_template('register.html', title='Registrer', form=form)
            

              
                Copy
              
            
          

Passordhashing med Flask-Bcrypt

Den viktigste linjen i koden ovenfor er:

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

Bcrypt er en moderne, adaptiv hashing-algoritme. Den tar brukerens passord og utfører en kompleks, beregningsmessig dyr enveis-transformasjon på det. Den inkluderer også et tilfeldig "salt" for hvert passord for å forhindre regnbuetabellangrep. Dette betyr at selv om to brukere har samme passord, vil deres lagrede hasher være helt forskjellige. Den resulterende hashen er det vi lagrer i databasen. Det er praktisk talt umulig å reversere denne prosessen for å få det originale passordet.

Brukerpålogging: Autentisering av eksisterende brukere

La oss nå legge til påloggingsruten i vår `app/routes.py`-fil.

app/routes.py (legg til denne ruten):

            @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('Pålogging mislyktes. Vennligst sjekk e-post og passord', 'danger')
    return render_template('login.html', title='Logg inn', form=form)
            

              
                Copy
              
            
          

Nøkkeltrinnene her er:

1. Finn brukeren: Vi spør databasen etter en bruker med den innsendte e-postadressen.
2. Verifiser passordet: Dette er den avgjørende sjekken: `bcrypt.check_password_hash(user.password_hash, form.password.data)`. Denne funksjonen tar den lagrede hashen fra databasen vår og passordet i ren tekst som brukeren nettopp skrev inn. Den hasjerer det innsendte passordet på nytt ved å bruke samme salt (som er lagret som en del av hashen selv) og sammenligner resultatene. Den returnerer `True` bare hvis de samsvarer. Dette lar oss verifisere et passord uten å måtte dekryptere den lagrede hashen.
3. Administrer sesjonen: Hvis passordet er riktig, kaller vi `login_user(user, remember=form.remember.data)`. Denne funksjonen fra `Flask-Login` registrerer brukeren som pålogget, og lagrer deres ID i brukersesjonen (en sikker, servertjener-side cookie). `remember`-argumentet håndterer "Husk meg"-funksjonaliteten.

Brukerutlogging: Avslutter en sesjon sikkert

Utlogging er enkelt. Vi trenger bare en rute som kaller `Flask-Login`s `logout_user`-funksjon.

app/routes.py (legg til denne ruten):

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

              
                Copy
              
            
          

Denne funksjonen vil fjerne brukerens ID fra sesjonen, og effektivt logge dem ut.

Del 3: Beskytte ruter og administrere brukersesjoner

Nå som brukere kan logge inn og ut, må vi utnytte deres autentiserte tilstand.

Beskytte innhold med `@login_required`

Mange sider, som en brukers dashbord eller kontoinnstillinger, skal bare være tilgjengelige for påloggede brukere. `Flask-Login` gjør dette utrolig enkelt med `@login_required`-dekoratoren.

La oss opprette en beskyttet dashbordrute.

app/routes.py (legg til denne ruten):

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

              
                Copy
              
            
          

Det er det! Hvis en bruker som ikke er logget inn prøver å besøke `/dashboard`, vil `Flask-Login` automatisk avskjære forespørselen og omdirigere dem til påloggingssiden (som vi konfigurerte i `app/__init__.py` med `login_manager.login_view = 'main.login'`). Etter at de har logget inn, vil den intelligent omdirigere dem tilbake til dashbordssiden de opprinnelig prøvde å få tilgang til.

Tilgang til nåværende brukers informasjon

Innenfor rutene og malene dine gir `Flask-Login` et magisk proxy-objekt kalt `current_user`. Dette objektet representerer brukeren som for øyeblikket er logget inn for den aktive forespørselen. Hvis ingen bruker er logget inn, er det et anonymt brukerobjekt der `current_user.is_authenticated` vil være `False`.

Du kan bruke dette i Python-koden din:

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

              
                Copy
              
            
          

Og du kan også bruke det direkte i dine Jinja2-maler:

            <!-- I en mal som base.html -->
{% if current_user.is_authenticated %}
    <a href="{{ url_for('main.dashboard') }}">Dashbord</a>
    <a href="{{ url_for('main.logout') }}">Logg ut</a>
{% else %}
    <a href="{{ url_for('main.login') }}">Logg inn</a>
    <a href="{{ url_for('main.register') }}">Registrer</a>
{% endif %}
            

              
                Copy
              
            
          

Dette lar deg dynamisk endre navigasjonslinjen eller andre deler av brukergrensesnittet basert på brukerens påloggingsstatus.

HTML-maler

For fullstendighet, her er noen grunnleggende maler du kan plassere i `app/templates`-katalogen. De bruker enkel HTML, men kan enkelt integreres med et rammeverk som Bootstrap eller Tailwind CSS.

base.html:

            <!DOCTYPE html>
<html lang="en">
<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') }}">Dashbord</a>
            <a href="{{ url_for('main.logout') }}">Logg ut</a>
        {% else %}
            <a href="{{ url_for('main.login') }}">Logg inn</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 registreringsskjema):

            {% extends "base.html" %}
{% block content %}
    <div>
        <form method="POST" action="">
            {{ form.hidden_tag() }}
            <fieldset>
                <legend>Bli med 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: Avanserte emner og sikkerhetsbeste praksiser

Systemet vi har bygget er solid, men en produksjonsklar applikasjon krever mer. Her er essensielle neste trinn og sikkerhetshensyn.

1. Funksjonalitet for tilbakestilling av passord

Brukere vil uunngåelig glemme passordene sine. En sikker flyt for tilbakestilling av passord er avgjørende. Den standard, sikre prosessen er:

1. Brukeren skriver inn sin e-postadresse på en "Glemt passord"-side.
2. Applikasjonen genererer en sikker, engangs, tidsfølsom token. `itsdangerous`-biblioteket (installert med Flask) er perfekt for dette.
3. Applikasjonen sender en e-post til brukeren som inneholder en lenke med denne tokenen.
4. Når brukeren klikker på lenken, validerer applikasjonen tokenen (kontrollerer gyldighet og utløp).
5. Hvis gyldig, presenteres brukeren med et skjema for å skrive inn og bekrefte et nytt passord.

Send aldri brukerens gamle passord eller et nytt passord i ren tekst via e-post.

2. E-postbekreftelse ved registrering

For å forhindre at brukere registrerer seg med falske e-postadresser og for å sikre at du kan kontakte dem, bør du implementere et e-postbekreftelsestrinn. Prosessen er veldig lik en tilbakestilling av passord: generer en token, send en bekreftelseslenke via e-post, og ha en rute som validerer tokenen og merker brukerens konto som `confirmed` i databasen.

3. Hastighetsbegrensning for å forhindre "brute-force"-angrep

Et "brute-force"-angrep er når en angriper gjentatte ganger prøver forskjellige passord på et påloggingsskjema. For å redusere dette, bør du implementere hastighetsbegrensning. Dette begrenser antall påloggingsforsøk en enkelt IP-adresse kan gjøre innenfor en viss tidsramme (f.eks. 5 mislykkede forsøk per minutt). `Flask-Limiter`-utvidelsen er et utmerket verktøy for dette.

4. Bruk av miljøvariabler for alle hemmeligheter

Vi har allerede gjort dette for vår `SECRET_KEY` og `DATABASE_URL`, noe som er flott. Det er en kritisk praksis for sikkerhet og portabilitet. Aldri lagre din `.env`-fil eller noen fil med hardkodede legitimasjoner (som API-nøkler eller databasepassord) i et offentlig versjonskontrollsystem som GitHub. Bruk alltid en `.gitignore`-fil for å ekskludere dem.

5. Beskyttelse mot "Cross-Site Request Forgery" (CSRF)

Gode nyheter! Ved å bruke `Flask-WTF` og inkludere `{{ form.hidden_tag() }}` i skjemaene våre, har vi allerede aktivert CSRF-beskyttelse. Denne skjulte taggen genererer en unik token for hver skjemainnsending, noe som sikrer at forespørselen kommer fra ditt faktiske nettsted og ikke fra en ondsinnet ekstern kilde som prøver å lure brukerne dine.

Konklusjon: Dine neste skritt innen Flask-autentisering

Gratulerer! Du har vellykket bygget et komplett og sikkert brukerautentiseringssystem i Flask. Vi har dekket hele livssyklusen: sette opp et skalerbart prosjekt, opprette en databasemodell, sikkert håndtere brukerregistrering med passordhashing, autentisere brukere, administrere sesjoner med Flask-Login og beskytte ruter.

Du har nå et robust fundament som du trygt kan integrere i ethvert Flask-prosjekt. Husk at sikkerhet er en pågående prosess, ikke et engangsoppsett. Prinsippene vi har diskutert – spesielt hashing av passord og beskyttelse av hemmelige nøkler – er ikke-forhandlingsbare for enhver applikasjon som håndterer brukerdata.

Herfra kan du utforske enda mer avanserte autentiseringsemner for å forbedre applikasjonen din ytterligere:

• Rollebasert tilgangskontroll (RBAC): Legg til et `role`-felt i brukermodellen din for å gi forskjellige tillatelser til vanlige brukere og administratorer.
• OAuth-integrasjon: Tillat brukere å logge inn ved hjelp av tredjepartstjenester som Google, GitHub eller Facebook.
• Tofaktorautentisering (2FA): Legg til et ekstra sikkerhetslag ved å kreve en kode fra en autentiseringsapp eller SMS.

Ved å mestre grunnleggende autentisering har du tatt et betydelig skritt fremover i din reise som en profesjonell webutvikler. Lykke til med kodingen!