Flask-autentisering: En omfattande guide för att bygga säkra inloggningssystem

I dagens digitala värld kräver nästan alla meningsfulla webbapplikationer ett sätt att hantera och identifiera sina användare. Oavsett om du bygger ett socialt nätverk, en e-handelsplattform eller ett företagsintranät, är ett säkert och pålitligt autentiseringssystem inte bara en funktion – det är ett grundläggande krav. Det är den digitala grindvakten som skyddar användardata, personaliserar upplevelser och möjliggör förtroende.

Flask, det populära Python-mikroramverket, erbjuder flexibiliteten att bygga kraftfulla webbapplikationer, men det lämnar medvetet autentiseringsimplementeringen till utvecklaren. Detta minimalistiska tillvägagångssätt är en styrka, vilket gör att du kan välja de bästa verktygen för jobbet utan att vara låst till en specifik metodik. Det innebär dock också att du är ansvarig för att bygga systemet korrekt och säkert.

Denna omfattande guide är utformad för en internationell publik av utvecklare. Vi kommer att guida dig genom varje steg för att bygga ett komplett, produktionsklart inloggningssystem för användare i Flask. Vi börjar med det absoluta grundläggande och bygger gradvis upp till en robust lösning, som täcker viktiga säkerhetsrutiner längs vägen. I slutet av denna handledning kommer du att ha kunskapen och koden för att implementera säker användarregistrering, inloggning och sessionshantering i dina egna Flask-projekt.

Förutsättningar: Konfigurera din utvecklingsmiljö

Innan vi skriver vår första rad autentiseringskod behöver vi upprätta en ren och organiserad utvecklingsmiljö. Detta är en universell bästa praxis inom mjukvaruutveckling, som säkerställer att ditt projekts beroenden inte krockar med andra projekt på ditt system.

1. Python och virtuella miljöer

Se till att du har Python 3.6 eller senare installerat på ditt system. Vi kommer att använda en virtuell miljö för att isolera vårt projekts paket. Öppna din terminal eller kommandotolk och kör följande kommandon:

            # Skapa en projektkatalog
mkdir flask-auth-project
cd flask-auth-project

# Skapa en virtuell miljö (mappen 'venv')
python3 -m venv venv

# Aktivera den virtuella miljön
# På macOS/Linux:
source venv/bin/activate
# På Windows:
venv\Scripts\activate
            

              
                Copy
              
            
          

Du vet att miljön är aktiv när du ser `(venv)` som prefix på din kommandotolk.

2. Installera nödvändiga Flask-tillägg

Vårt autentiseringssystem kommer att byggas på en stapel av utmärkta, väl underhållna Flask-tillägg. Var och en tjänar ett specifikt syfte:

• Flask: Kärnwebbramverket.
• Flask-SQLAlchemy: En Object-Relational Mapper (ORM) för att interagera med vår databas på ett Pythoniskt sätt.
• Flask-Migrate: Hanterar databasschemamigreringar.
• Flask-WTF: Förenklar arbetet med webbformulär, ger validering och CSRF-skydd.
• Flask-Login: Hanterar användarsessionen, hanterar inloggning, utloggning och att komma ihåg användare.
• Flask-Bcrypt: Ger starka lösenordskrypteringsfunktioner.
• python-dotenv: Hanterar miljövariabler för konfiguration.

Installera dem alla med ett enda kommando:

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

              
                Copy
              
            
          

Del 1: Grunden - Projektstruktur och databasmodell

Ett välorganiserat projekt är lättare att underhålla, skala och förstå. Vi kommer att använda ett vanligt Flask-applikationsfabriksmönster.

Designa en skalbar projektstruktur

Skapa följande katalog- och filstruktur inuti din `flask-auth-project`-katalog:

            /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: Huvudpaketet som innehåller vår applikationslogik.
• /templates: Kommer att innehålla våra HTML-filer.
• __init__.py: Initierar vår Flask-applikation (applikationsfabriken).
• models.py: Definierar våra databastabeller (t.ex. User-modellen).
• forms.py: Definierar våra registrerings- och inloggningsformulär med Flask-WTF.
• routes.py: Innehåller våra vyfunktioner (logiken för olika URL:er).
• config.py: Lagrar applikationens konfigurationsinställningar.
• run.py: Huvudskriptet för att starta webbservern.
• .env: En fil för att lagra miljövariabler som hemliga nycklar (denna fil bör INTE checkas in i versionshanteringen).

Konfigurera din Flask-applikation

Låt oss fylla våra konfigurationsfiler.

.env fil:

Skapa denna fil i roten av ditt projekt. Det är här vi lagrar känslig information.

            SECRET_KEY='en-mycket-stark-och-lång-slumpmässig-hemlig-nyckel'
DATABASE_URL='sqlite:///site.db'
            

              
                Copy
              
            
          

VIKTIGT: Ersätt värdet för `SECRET_KEY` med din egen långa, slumpmässiga och oförutsägbara sträng. Denna nyckel är avgörande för att säkra användarsessioner.

config.py fil:

Denna fil läser konfigurationen från 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
              
            
          

Skapa användarmodellen med Flask-SQLAlchemy

User-modellen är hjärtat i vårt autentiseringssystem. Den definierar strukturen för `users`-tabellen i vår databas.

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
              
            
          

Låt oss bryta ner detta:

• `UserMixin`: Detta är en klass från `Flask-Login` som innehåller generiska implementeringar för metoder som `is_authenticated`, `is_active` etc., som vår User-modell behöver.
• `@login_manager.user_loader`: Denna funktion är ett krav för `Flask-Login`. Den används för att ladda om användarobjektet från användar-ID:t som lagras i sessionen. Flask-Login kommer att anropa denna funktion vid varje begäran för en inloggad användare.
• `password_hash`: Observera att vi INTE lagrar lösenordet direkt. Vi lagrar en `password_hash`. Detta är en av de mest kritiska säkerhetsprinciperna inom autentisering. Att lagra lösenord i klartext är en enorm säkerhetsbrist. Om din databas någonsin komprometteras kommer angripare att ha alla användares lösenord. Genom att lagra en hash gör vi det beräkningsmässigt ogenomförbart för dem att hämta de ursprungliga lösenorden.

Initiera applikationen

Nu binder vi ihop allt i vår applikationsfabrik.

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' # Omdirigeringssida för användare som inte är inloggade
login_manager.login_message_category = 'info' # Bootstrap-klass för meddelanden

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
              
            
          

Innan vi kan köra appen måste vi skapa databasen. Från din aktiverade virtuella miljö i terminalen, kör dessa kommandon:

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

              
                Copy
              
            
          

Detta kommer att skapa en `site.db`-fil i din rotkatalog, som innehåller `user`-tabellen vi definierade.

Del 2: Bygga den centrala autentiseringslogiken

Med grunden på plats kan vi nu bygga de användarvända delarna: registrerings- och inloggningsformulär samt de routes som bearbetar dem.

Användarregistrering: Registrera nya användare säkert

Först definierar vi formuläret med 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('Username',
                           validators=[DataRequired(), Length(min=2, max=20)])
    email = StringField('Email',
                        validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired()])
    confirm_password = PasswordField('Confirm Password',
                                     validators=[DataRequired(), EqualTo('password')])
    submit = SubmitField('Sign Up')

    def validate_username(self, username):
        user = User.query.filter_by(username=username.data).first()
        if user:
            raise ValidationError('That username is taken. Please choose a different one.')

    def validate_email(self, email):
        user = User.query.filter_by(email=email.data).first()
        if user:
            raise ValidationError('That email is already registered. Please choose a different one.')

class LoginForm(FlaskForm):
    email = StringField('Email',
                        validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired()])
    remember = BooleanField('Remember Me')
    submit = SubmitField('Login')
            

              
                Copy
              
            
          

Lägg märke till de anpassade valideringarna `validate_username` och `validate_email`. Flask-WTF anropar automatiskt alla metoder med mönstret `validate_` och använder dem som anpassade valideringar för det fältet. Det är så vi kontrollerar om ett användarnamn eller en e-postadress redan finns i databasen.

Sedan skapar vi routern för att hantera registreringen.

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('Your account has been created! You are now able to log in', 'success')
        return redirect(url_for('main.login'))
    return render_template('register.html', title='Register', form=form)
            

              
                Copy
              
            
          

Lösenordskryptering med Flask-Bcrypt

Den viktigaste raden i koden ovan är:

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

Bcrypt är en modern, adaptiv krypteringsalgoritm. Den tar användarens lösenord och utför en komplex, beräkningsmässigt kostsam envägsomvandling på det. Den inkluderar också ett slumpmässigt "salt" för varje lösenord för att förhindra attacker med regnbågstabeller. Detta innebär att även om två användare har samma lösenord, kommer deras lagrade hashvärden att vara helt olika. Den resulterande hashen är vad vi lagrar i databasen. Det är nästan omöjligt att reversera denna process för att få det ursprungliga lösenordet.

Användarinloggning: Autentisera befintliga användare

Nu lägger vi till inloggningsroutern till vår `app/routes.py`-fil.

app/routes.py (lägg till denna route):

            @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 Unsuccessful. Please check email and password', 'danger')
    return render_template('login.html', title='Login', form=form)
            

              
                Copy
              
            
          

De viktigaste stegen här är:

1. Hitta användaren: Vi gör en databasfråga efter en användare med den angivna e-postadressen.
2. Verifiera lösenordet: Detta är den avgörande kontrollen: `bcrypt.check_password_hash(user.password_hash, form.password.data)`. Denna funktion tar den lagrade hashen från vår databas och det klartextlösenord som användaren just angav. Den krypterar det angivna lösenordet igen med samma salt (som är lagrat som en del av själva hashen) och jämför resultaten. Den returnerar `True` endast om de matchar. Detta gör att vi kan verifiera ett lösenord utan att någonsin behöva dekryptera den lagrade hashen.
3. Hantera sessionen: Om lösenordet är korrekt anropar vi `login_user(user, remember=form.remember.data)`. Denna funktion från `Flask-Login` registrerar användaren som inloggad och lagrar deras ID i användarsessionen (en säker, serversides-cookie). Argumentet `remember` hanterar funktionen "Kom ihåg mig".

Användarutloggning: Avsluta en session säkert

Utloggning är enkelt. Vi behöver bara en route som anropar `Flask-Login`s `logout_user`-funktion.

app/routes.py (lägg till denna route):

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

              
                Copy
              
            
          

Denna funktion rensar användar-ID:t från sessionen, vilket effektivt loggar ut dem.

Del 3: Skydda routes och hantera användarsessioner

Nu när användare kan logga in och ut måste vi utnyttja deras autentiserade status.

Skydda innehåll med `@login_required`

Många sidor, som en användares instrumentpanel eller kontoinställningar, bör endast vara tillgängliga för inloggade användare. `Flask-Login` gör detta otroligt enkelt med dekoratören `@login_required`.

Låt oss skapa en skyddad instrumentpanelsroute.

app/routes.py (lägg till denna route):

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

              
                Copy
              
            
          

Det var allt! Om en användare som inte är inloggad försöker besöka `/dashboard`, kommer `Flask-Login` automatiskt att avbryta begäran och omdirigera dem till inloggningssidan (vilket vi konfigurerade i `app/__init__.py` med `login_manager.login_view = 'main.login'`). Efter att de framgångsrikt har loggat in, kommer den intelligent att omdirigera dem tillbaka till instrumentpanelsidan de ursprungligen försökte komma åt.

Åtkomst till den aktuella användarens information

Inom dina routes och mallar tillhandahåller `Flask-Login` ett magiskt proxobjekt som kallas `current_user`. Detta objekt representerar den användare som för närvarande är inloggad för den aktiva begäran. Om ingen användare är inloggad är det ett anonymt användarobjekt där `current_user.is_authenticated` kommer att vara `False`.

Du kan använda detta i din Python-kod:

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

              
                Copy
              
            
          

Och du kan också använda det direkt i dina Jinja2-mallar:

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

              
                Copy
              
            
          

Detta gör det möjligt för dig att dynamiskt ändra navigeringsfältet eller andra delar av din UI baserat på användarens inloggningsstatus.

HTML-mallar

För fullständighetens skull, här är några grundläggande mallar som du kan placera i `app/templates`-katalogen. De använder enkel HTML men kan enkelt integreras med ett ramverk 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') }}">Home</a>
        {% if current_user.is_authenticated %}
            <a href="{{ url_for('main.dashboard') }}">Dashboard</a>
            <a href="{{ url_for('main.logout') }}">Logout</a>
        {% else %}
            <a href="{{ url_for('main.login') }}">Login</a>
            <a href="{{ url_for('main.register') }}">Register</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 (exempel med registreringsformulär):

            {% extends "base.html" %}
{% block content %}
    <div>
        <form method="POST" action="">
            {{ form.hidden_tag() }}
            <fieldset>
                <legend>Join Today</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: Avancerade ämnen och säkerhetsrutiner

Systemet vi har byggt är stabilt, men en produktionsgradig applikation kräver mer. Här är viktiga nästa steg och säkerhetsöverväganden.

1. Återställning av lösenord

Användare kommer oundvikligen att glömma sina lösenord. Ett säkert flöde för återställning av lösenord är avgörande. Den standardiserade, säkra processen är:

1. Användaren anger sin e-postadress på en sida för "Glömt lösenord".
2. Applikationen genererar en säker, engångsanvänd, tidsbegränsad token. `itsdangerous`-biblioteket (installerat med Flask) är perfekt för detta.
3. Applikationen skickar ett e-postmeddelande till användaren som innehåller en länk med denna token.
4. När användaren klickar på länken validerar applikationen token (kontrollerar dess giltighet och utgångsdatum).
5. Om den är giltig presenteras användaren med ett formulär för att ange och bekräfta ett nytt lösenord.

Skicka aldrig ett användares gamla lösenord eller ett nytt lösenord i klartext via e-post.

2. E-postbekräftelse vid registrering

För att förhindra att användare registrerar sig med falska e-postadresser och för att säkerställa att du kan kontakta dem, bör du implementera ett steg för e-postbekräftelse. Processen liknar mycket en lösenordsåterställning: generera en token, skicka en bekräftelselänk via e-post och ha en route som validerar token och markerar användarens konto som `bekräftat` i databasen.

3. Rate limiting för att förhindra brute-force-attacker

En brute-force-attack är när en angripare upprepade gånger försöker olika lösenord på ett inloggningsformulär. För att mildra detta bör du implementera rate limiting. Detta begränsar antalet inloggningsförsök som en enskild IP-adress kan göra inom en viss tidsram (t.ex. 5 misslyckade försök per minut). `Flask-Limiter`-tillägget är ett utmärkt verktyg för detta.

4. Använd miljövariabler för alla hemligheter

Vi har redan gjort detta för vår `SECRET_KEY` och `DATABASE_URL`, vilket är utmärkt. Det är en kritisk praxis för säkerhet och portabilitet. Checka aldrig in din `.env`-fil eller någon fil med hårdkodade inloggningsuppgifter (som API-nycklar eller databaslösenord) i ett publikt versionshanteringssystem som GitHub. Använd alltid en `.gitignore`-fil för att exkludera dem.

5. Cross-Site Request Forgery (CSRF)-skydd

Goda nyheter! Genom att använda `Flask-WTF` och inkludera `{{ form.hidden_tag() }}` i våra formulär har vi redan aktiverat CSRF-skydd. Denna dolda tagg genererar en unik token för varje formulärinlämning, vilket säkerställer att begäran kommer från din faktiska webbplats och inte från en skadlig extern källa som försöker lura dina användare.

Slutsats: Dina nästa steg inom Flask-autentisering

Grattis! Du har framgångsrikt byggt ett komplett och säkert användarautentiseringssystem i Flask. Vi har täckt hela livscykeln: konfigurerat ett skalbart projekt, skapat en databasmodell, säkert hanterat användarregistrering med lösenordskryptering, autentiserat användare, hanterat sessioner med Flask-Login och skyddat routes.

Du har nu en robust grund som du tryggt kan integrera i alla Flask-projekt. Kom ihåg att säkerhet är en pågående process, inte en engångsinstallation. De principer vi har diskuterat – särskilt kryptering av lösenord och skydd av hemliga nycklar – är icke-förhandlingsbara för alla applikationer som hanterar användardata.

Härifrån kan du utforska ännu mer avancerade autentiseringsteman för att ytterligare förbättra din applikation:

• Rollbaserad åtkomstkontroll (RBAC): Lägg till ett `role`-fält till din User-modell för att ge olika behörigheter till vanliga användare och administratörer.
• OAuth-integration: Låt användare logga in med hjälp av tredjepartstjänster som Google, GitHub eller Facebook.
• Tvåfaktorsautentisering (2FA): Lägg till ett extra säkerhetslager genom att kräva en kod från en autentiseringsapp eller SMS.

Genom att bemästra grunderna för autentisering har du tagit ett betydande steg framåt i din resa som professionell webbutvecklare. Lycka till med kodningen!