Implementierung der Authentifizierung mit JWT in FastAPI

Einführung

In der modernen Webanwendungsentwicklung ist die Authentifizierung ein entscheidender Bestandteil zur Gewährleistung der Systemsicherheit. JSON Web Token (JWT), als offener Standard basierend auf JSON (RFC 7519), wird aufgrund seiner Kompaktheit und Sicherheit häufig in Single-Sign-On (SSO)-Szenarien für verteilte Sites verwendet. FastAPI ist ein leistungsstarkes Webframework basierend auf Python. Dieser Artikel stellt vor, wie JWT für die Authentifizierung in FastAPI verwendet wird, kombiniert mit dem gegebenen JWT-Implementierungscode.

Grundlagen von JWT

Was ist JWT?

JSON Web Token (JWT) wurde entwickelt, um Ansprüche zwischen Netzwerk-Anwendungsumgebungen zu übertragen. Es ist kompakt und sicher, besonders geeignet für Single-Sign-On-Szenarien in verteilten Sites. JWT-Ansprüche werden oft verwendet, um die authentifizierten Benutzeridentitätsinformationen zwischen dem Identitätsanbieter und dem Dienstanbieter zu übertragen, um Ressourcen vom Ressourcenserver zu beziehen, und können auch andere Anspruchsinformationen hinzufügen, die von der Geschäftslogik benötigt werden. Dieses Token kann direkt zur Authentifizierung verwendet oder verschlüsselt werden.

Zusammensetzung von JWT

JWT besteht aus drei Informationssegmenten:

• Header: Deklariert normalerweise den Dateityp und den Verschlüsselungsalgorithmus.
• Payload: Zeichnet die zu übertragenden Daten im JSON-Format auf.
• Signatur: Eine zur Verifizierung verwendete Signatur.

base64UrlEncode Methode

Beim Generieren eines JWT wird die base64UrlEncode-Methode für die Signatur verwendet. Die grundlegenden Funktionen dieser Methode sind wie folgt:

1. Eingabe einer UTF-8-kodierten Zeichenkette s1.
2. Kodieren der Zeichenkette s1 mit base64, um die Zeichenkette s2 zu erhalten.
3. Wenn am Ende von s2 Gleichheitszeichen stehen, entfernen Sie alle Gleichheitszeichen am Ende.
4. Wenn in s2 Pluszeichen (+) vorhanden sind, ersetzen Sie alle Pluszeichen durch Minuszeichen (-).
5. Wenn in s2 Schrägstriche (/) vorhanden sind, ersetzen Sie alle Schrägstriche durch Unterstriche (_).

Das Folgende ist der Python-Code zur Implementierung dieser Methode:

import hmac
import base64
from hashlib import sha256
from urllib import parse as urlp

def b64url(str1):
    if type(str1) == str:
        return str(base64.b64encode(str1.encode('utf-8')), encoding="utf-8").strip('=').replace('+', '-').replace('/', '_')
    elif type(str1) == bytes:
        return str(base64.b64encode(str1), encoding="utf-8").strip('=').replace('+', '-').replace('/', '_')
    else:
        raise TypeError("The type of given argument must be string or bytes")

Generieren eines mit HS256 verschlüsselten JWT

Das Folgende ist der Code, um ein mit HS256 verschlüsseltes JWT unter Verwendung der obigen b64url-Funktion zu generieren:

# Hier Ihre Informationen eingeben ...
header = b64url('{"alg":"HS256","typ":"JWT"}')
payload = b64url('{"sub":"1234567890","name":"John Doe","iat":1516239022}')
secret = 'happynewyear'.encode('utf-8')
# ###

sig = b64url(hmac.new(
    secret, (header + '.' + payload).encode('utf-8'), digestmod=sha256
).digest())

jwt = header + '.' + payload + '.' + sig
print(jwt)

Integrieren von JWT in FastAPI

Installieren von Abhängigkeiten

Bevor Sie beginnen, müssen Sie fastapi und uvicorn installieren. Sie können den folgenden Befehl verwenden, um sie zu installieren:

pip install fastapi uvicorn

Implementierungsschritte

1. Erstellen einer FastAPI-Anwendung

from fastapi import FastAPI, HTTPException, Depends
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import hmac
import base64
from hashlib import sha256

app = FastAPI()

# Definieren der b64url-Funktion
def b64url(str1):
    if type(str1) == str:
        return str(base64.b64encode(str1.encode('utf-8')), encoding="utf-8").strip('=').replace('+', '-').replace('/', '_')
    elif type(str1) == bytes:
        return str(base64.b64encode(str1), encoding="utf-8").strip('=').replace('+', '-').replace('/', '_')
    else:
        raise TypeError("The type of given argument must be string or bytes")

# Geheimer Schlüssel
SECRET_KEY = 'happynewyear'.encode('utf-8')

# Funktion zum Generieren von JWT
def generate_jwt():
    header = b64url('{"alg":"HS256","typ":"JWT"}')
    payload = b64url('{"sub":"1234567890","name":"John Doe","iat":1516239022}')
    sig = b64url(hmac.new(
        SECRET_KEY, (header + '.' + payload).encode('utf-8'), digestmod=sha256
    ).digest())
    return header + '.' + payload + '.' + sig

# Funktion zum Verifizieren von JWT
def verify_jwt(token: str):
    parts = token.split('.')
    if len(parts) != 3:
        return False
    header, payload, received_sig = parts
    new_sig = b64url(hmac.new(
        SECRET_KEY, (header + '.' + payload).encode('utf-8'), digestmod=sha256
    ).digest())
    return new_sig == received_sig

# Definieren der JWT-Verifizierungsabhängigkeit
class JWTBearer(HTTPBearer):
    def __init__(self, auto_error: bool = True):
        super(JWTBearer, self).__init__(auto_error=auto_error)

    async def __call__(self, request):
        credentials: HTTPAuthorizationCredentials = await super(JWTBearer, self).__call__(request)
        if credentials:
            if not credentials.scheme == "Bearer":
                raise HTTPException(status_code=401, detail="Invalid authentication scheme.")
            if not verify_jwt(credentials.credentials):
                raise HTTPException(status_code=401, detail="Invalid or expired token.")
            return credentials.credentials
        else:
            raise HTTPException(status_code=401, detail="Invalid authorization code.")

2. Erstellen einer Login-Schnittstelle

# Simulierte Login-Schnittstelle
@app.post("/login")
def login():
    token = generate_jwt()
    return {"access_token": token, "token_type": "bearer"}

3. Erstellen einer geschützten Schnittstelle

# Geschützte Schnittstelle
@app.get("/protected", dependencies=[Depends(JWTBearer())])
def protected_route():
    return {"message": "This is a protected route."}

Ausführen der Anwendung

Speichern Sie den obigen Code als main.py und führen Sie dann den folgenden Befehl im Terminal aus, um die Anwendung zu starten:

uvicorn main:app --reload

Testen der Schnittstellen

• Login-Schnittstelle: Verwenden Sie Tools wie curl oder Postman, um eine POST-Anfrage an http://localhost:8000/login zu senden, und es wird ein JWT zurückgegeben.

curl -X POST http://localhost:8000/login

• Geschützte Schnittstelle: Verwenden Sie das zurückgegebene JWT, um eine GET-Anfrage an http://localhost:8000/protected zu senden, und fügen Sie Authorization: Bearer <your_token> zum Anfrageheader hinzu.

curl -X GET http://localhost:8000/protected -H "Authorization: Bearer <your_token>"

Fazit

Durch die obigen Schritte haben Sie gelernt, wie JWT für die Authentifizierung in FastAPI verwendet wird. JWT bietet eine sichere und bequeme Möglichkeit, Benutzeridentitäten zu verwalten, was die Authentifizierung zwischen verteilten Systemen effizienter macht. In praktischen Anwendungen können Sie die Erzeugungs- und Verifizierungslogik von JWT an Ihre Bedürfnisse anpassen, z. B. Hinzufügen einer Ablaufzeit, Anpassen von Ansprüchen usw.

Leapcell: Das Beste aus Serverlosem Webhosting

Schließlich möchte ich eine Plattform empfehlen, die sich am besten für die Bereitstellung von Python-Diensten eignet: Leapcell

🚀 Entwickeln Sie mit Ihrer Lieblingssprache

Entwickeln Sie mühelos in JavaScript, Python, Go oder Rust.

🌍 Stellen Sie unbegrenzt Projekte kostenlos bereit

Zahlen Sie nur für das, was Sie verwenden – keine Anfragen, keine Gebühren.

⚡ Pay-as-You-Go, keine versteckten Kosten

Keine Leerlaufgebühren, nur nahtlose Skalierbarkeit.

📖 Entdecken Sie unsere Dokumentation

🔹 Folgen Sie uns auf Twitter: @LeapcellHQ