Hvordan implementere RBAC og tofaktorautentisering i API-er med FastAPI

Å implementere tilgangskontroll i applikasjoner er avgjørende for å beskytte sensitive data og sikre at bare autoriserte brukere kan utføre bestemte handlinger. I denne delen diskuterer vi hvordan man kan bruke Roll-Based Access Control (RBAC) for å beskytte API-ruter, samt hvordan tofaktorautentisering (2FA) kan forbedre sikkerheten ytterligere. Vi vil bruke FastAPI som rammeverk og gå gjennom konkrete eksempler på hvordan disse konseptene kan implementeres.

I FastAPI kan vi implementere RBAC ved å bruke avhengigheter og tillatelseslogikk i ruter. La oss anta at vi har en rute hvor bare administratorer kan slette brukere, og at både moderatorer og administratorer kan utestenge brukere. Eksemplet nedenfor viser hvordan dette kan gjøres.

python
Copy code
from fastapi import APIRouter, Depends

from app.permissions import permission_required
router = APIRouter()
@router.delete("/users/{user_id}")
def delete_user(user_id: int, current_user = Depends(get_current_user), perm = permission_required("delete_user")):
    # Tjenestelogikk her
    # Kun administratorer vil nå dette punktet
    return {"msg": f"User {user_id} deleted"}
@router.post("/users/{user_id}/ban")
def ban_user(user_id: int, current_user = Depends(get_current_user), perm = permission_required("ban_user")):
    # Kun moderatorer eller administratorer kan nå her
    return {"msg": f"User {user_id} banned"}

Med dette systemet kan vi være sikre på at ingen brukere uten passende rolle kan utføre sensitive handlinger, som å slette eller blokkere brukere. FastAPI sørger for at autentisering skjer før forretningslogikken utføres, og hvis en bruker prøver å få tilgang til en beskyttet rute uten nødvendige tillatelser, vil de motta en 403-feil (forbudt).

python
Copy code
from fastapi import Request
from starlette.middleware.base import BaseHTTPMiddleware
class RBACMiddleware(BaseHTTPMiddleware):

    async def dispatch(self, request: Request, call_next):

        # Eksempel: logg eller håndhev RBAC globalt
        response = await call_next(request)
        return response

For applikasjoner som krever mer dynamiske rolle- og tillatelsesstyring, kan man vurdere å bruke en database for å lagre brukernes roller og tillatelser. Dette gir muligheten til å oppdatere roller og tillatelser i sanntid, uten å måtte gjøre endringer i koden. Ved å bruke et database-basert system kan man enkelt legge til nye roller eller endre eksisterende roller uten nedetid.

Et praktisk eksempel på hvordan dette kan gjøres, er å opprette en rute som lar administratorer endre roller for brukere:

python
Copy code
@router.patch("/users/{user_id}/role")

def update_role(user_id: int, new_role: str, current_user = Depends(get_current_user), perm = permission_required("manage_roles"), db: Session = Depends(get_db)):
    user = db.query(UserModel).filter(UserModel.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    user.role = new_role
    db.commit()
    return {"msg": f"Role updated to {new_role}"}

For å implementere 2FA, må hver bruker ha en hemmelig nøkkel som deles mellom serveren og autentiseringsappen deres. Denne nøkkelen kan genereres og lagres ved hjelp av biblioteket pyotp. Når brukeren aktiverer 2FA, kan serveren sende en QR-kode som brukeren skanner med sin autentiseringsapp. Etter at appen er konfigurert, kan brukeren bekrefte oppsettet ved å oppgi en TOTP-kode fra appen.

Her er et eksempel på hvordan man kan generere en QR-kode for 2FA-enrollering:

python
Copy code
import pyotp

import qrcode
import io
import base64
@router.post("/2fa/enroll")
def enroll_2fa(current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)):
    if current_user.is_2fa_enabled:
        return {"msg": "2FA is already enabled"}
    secret = pyotp.random_base32()
    current_user.totp_secret = secret
    db.commit()
    issuer = "MyApp"
    email = current_user.email
    totp_uri = pyotp.totp.TOTP(secret).provisioning_uri(name=email, issuer_name=issuer)
    img = qrcode.make(totp_uri)
    buf = io.BytesIO()
    img.save(buf, format="PNG")
    qr_base64 = base64.b64encode(buf.getvalue()).decode()
    return {
        "qr_code": qr_base64,
        "manual_entry_key": secret,
        "msg": "Scan the QR with our authenticator app."
    }

Etter at brukeren har skannet QR-koden, kan de bekrefte oppsettet ved å oppgi en TOTP-kode fra appen. Hvis koden er riktig, blir 2FA aktivert for kontoen.

For å gjennomføre 2FA under pålogging, kan vi oppdatere påloggingsprosessen slik at en gyldig TOTP-kode må sendes inn etter at passordet er verifisert. Dette gir en ekstra lag med sikkerhet:

python
Copy code
@router.post("/login-2fa")

def login_2fa(data: LoginRequest, code: str = "", db: Session = Depends(get_db)):
    user = db.query(UserModel).filter(UserModel.email == data.email).first()
    if not user or not user.is_active:
        raise HTTPException(status_code=404, detail="User not found")
    # Verifiser 2FA-kode etter passord
    if user.is_2fa_enabled:
        totp = pyotp.TOTP(user.totp_secret)
        if not totp.verify(code):
            raise HTTPException(status_code=401, detail="Invalid 2FA code")
    return {"msg": "Login successful"}

Implementeringen av RBAC og 2FA gir et robust rammeverk for tilgangskontroll og brukerautentisering. Ved å kombinere rollebasert tilgang med tofaktorautentisering kan man beskytte applikasjoner på flere nivåer og redusere risikoen for uautorisert tilgang betydelig.

Hvordan sette opp et robust Python-utviklingsmiljø og implementere CRUD-funksjonalitet i en FastAPI-applikasjon

bash
Copy code
sudo apt update
sudo apt install -y software-properties-common
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update
sudo apt install -y python3.11 python3.11-venv python3.11-dev build-essential

Disse kommandoene gjør flere ting samtidig. Først oppdateres systemet til den nyeste pakkelisten, som sikrer at installasjonen går uten problemer. Deretter installeres nødvendige verktøy for å legge til nye repositorier. Repositoriet deadsnakes inneholder de nyeste Python-versjonene for Ubuntu. Etter at pakkelisten er oppdatert på nytt, installeres Python 3.11, virtuelle miljømoduler, utviklingsoverskrifter og verktøy for kompilering av C-utvidelser.

bash
Copy code
python3.11 -m venv .env

Dette oppretter et bibliotek kalt .env som inneholder en ny Python-tolk og et område for prosjektets avhengigheter. Når prosjektet utvikles, er det viktig å aktivere dette miljøet:

bash
Copy code
source .env/bin/activate

Fra dette punktet vil alle installasjoner og kommandoer kun kjøres i dette isolerte miljøet, som beskytter både system-Python og andre prosjekter. Når vi er ferdige med å jobbe, kan vi enkelt deaktivere miljøet med deactivate-kommandoen og gå tilbake til systemskallet.

makefile
Copy code
install: pip install -r requirements.txt
lint: black --check . flake8 .
test: pytest
dev: uvicorn app.main:app --reload

I denne Makefile-en blir avhengighetene installert med pip install -r requirements.txt, koden blir sjekket for stil med black og flake8, tester kjøres med pytest, og utviklingsserveren startes med uvicorn.

Når applikasjonen vokser, blir også håndteringen av konfigurasjoner og hemmeligheter mer utfordrende. Det er viktig å organisere konfigurasjonsfiler, som for eksempel .env.example og alembic.ini, i en egen config/-mappe. Dette gjør at vi kan holde oversikt over viktige innstillinger som databasens legitimasjon, hemmelige nøkler og migrasjonsinnstillinger på et sentralt sted. Når en ny konfigurasjonsvariabel er nødvendig, kan den enkelt legges til her uten risiko for å miste oversikten.

Vi starter med en enkel datamodell for å administrere bøker. Hver bok har et ID-nummer, tittel, forfatter, en valgfri beskrivelse og et publiseringsår. Dette er et passende utgangspunkt, og vi kan senere utvide til mer komplekse objekter. Pydantic-modellen gjør det mulig å validere data, sikre at alle nødvendige felter er til stede, og at dataene holder seg innenfor definerte grenser. For eksempel kan vi definere vår bokmodell slik:

python
Copy code
from pydantic import BaseModel, Field
from typing import Optional
class Book(BaseModel):
    id: int
    title: str = Field(..., min_length=1, max_length=255)
    author: str = Field(..., min_length=1, max_length=100)

    description: Optional[str] = Field(None, max_length=1000)

    year: int = Field(..., ge=1000, le=2100)

Med Pydantic kan vi også spesifisere minimums- og maksimumslengde for strenger og numeriske verdier for årstallet. Når dataene er ugyldige, vil FastAPI og Pydantic umiddelbart returnere en tydelig valideringsfeil.

En annen viktig praksis er å implementere et "service layer", som skiller forretningslogikk fra selve API-et. Dette gir enklere testing og bedre vedlikehold. Service-laget vil håndtere CRUD-operasjoner og levere data til API-laget. Her er et enkelt eksempel på en tjeneste for bøker som bruker et Python-dictionary som lagringssystem:

python
Copy code
from app.models import Book

from typing import Dict, List
class BookService:
    def __init__(self):
        self._books: Dict[int, Book] = {}
        self._id_counter: int = 1
    def create_book(self, data: Book) -> Book:
        data.id = self._id_counter
        self._books[self._id_counter] = data
        self._id_counter += 1
        return data
    def get_book(self, book_id: int) -> Book:
        if book_id not in self._books:
            raise KeyError("Book not found")
        return self._books[book_id]
    def list_books(self) -> List[Book]:
        return list(self._books.values())

    def update_book(self, book_id: int, data: Book) -> Book:

        if book_id not in self._books:
            raise KeyError("Book not found")
        data.id = book_id
        self._books[book_id] = data
        return data
    def delete_book(self, book_id: int) -> None:
        if book_id not in self._books:
            raise KeyError("Book not found")
        del self._books[book_id]

Med denne tjenesten kan vi utføre alle nødvendige CRUD-operasjoner på bøker. Den inneholder metoder for å opprette, hente, oppdatere og slette bøker. Hvis en bok ikke finnes, vil en KeyError bli kastet, og vi kan håndtere denne feilen i API-laget.

Når tjenesten er på plass, kan vi bruke FastAPI til å eksponere disse CRUD-operasjonene som RESTful-endepunkter. Dette gjør at vi kan samhandle med systemet via HTTP-metoder som POST (for opprettelse), GET (for henting), PUT (for oppdatering) og DELETE (for sletting).

Det som er viktig å forstå her, er hvordan hver komponent spiller en avgjørende rolle i systemet. Forståelsen av datamodellering og validering gjennom Pydantic, hvordan service-laget isolerer forretningslogikk, og hvordan FastAPI gir raske og sikre API-endepunkter, danner grunnlaget for robust applikasjonsutvikling. Med denne strukturen er det enklere å bygge applikasjoner som er både skalerbare og vedlikeholdbare, samtidig som de opprettholder høy kvalitet på koden og brukerdataene.