FastAPI Säkerhet: CORS och Säkerhetshuvuden för Robusta API:er

I dagens sammankopplade digitala landskap är det av största vikt att säkra dina API:er. FastAPI, ett modernt, högpresterande webbramverk för att bygga API:er med Python, erbjuder utmärkta verktyg och funktioner för att implementera robusta säkerhetsåtgärder. Denna omfattande guide går in på två viktiga aspekter av FastAPI-säkerhet: Cross-Origin Resource Sharing (CORS) och säkerhetshuvuden. Genom att förstå och implementera dessa tekniker kan du avsevärt förbättra skyddet av ditt API mot vanliga webbsårbarheter.

Förstå CORS (Cross-Origin Resource Sharing)

CORS är en webbläsares säkerhetsmekanism som begränsar webbsidor från att göra förfrågningar till en annan domän än den som webbsidan levererades från. Denna policy finns för att förhindra att skadliga webbplatser får åtkomst till känslig data från andra webbplatser utan korrekt auktorisering. Utan CORS kan en skurkaktig webbplats potentiellt göra obehöriga förfrågningar till ditt API på uppdrag av en inloggad användare, vilket leder till dataintrång eller andra säkerhetsexploateringar.

Varför är CORS Nödvändigt?

Föreställ dig ett scenario där en användare är inloggad på sitt onlinebankkonto. Samtidigt besöker de en skadlig webbplats. Utan CORS kan den skadliga webbplatsen potentiellt exekvera JavaScript-kod som skickar förfrågningar till användarens bank-API och överför pengar till angriparens konto. CORS förhindrar detta genom att som standard tillämpa en policy för samma ursprung.

Hur CORS Fungerar

När en webbläsare gör en korsursprungsförfrågan (en förfrågan till ett annat ursprung än den aktuella sidan) utför den först en "förhandsförfrågan" med HTTP OPTIONS-metoden. Denna förhandsförfrågan kontrollerar med servern för att avgöra om den faktiska förfrågan är tillåten. Servern svarar med huvuden som indikerar vilka ursprung, metoder och huvuden som är tillåtna. Om webbläsaren fastställer att förfrågan är tillåten baserat på serverns svar fortsätter den med den faktiska förfrågan. Annars blockeras förfrågan.

"Ursprunget" definieras av protokollet (t.ex. HTTP eller HTTPS), domänen (t.ex. example.com) och porten (t.ex. 80 eller 443). Två webbadresser anses ha samma ursprung endast om alla tre av dessa komponenter matchar exakt.

Konfigurera CORS i FastAPI

FastAPI förenklar processen att konfigurera CORS med hjälp av CORSMiddleware. Du kan lägga till denna middleware till din FastAPI-applikation för att aktivera CORS och specificera de tillåtna ursprungen, metoderna och huvudena.

Här är ett grundläggande exempel på hur du aktiverar CORS i FastAPI:

            
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

origins = [
    "http://localhost",
    "http://localhost:8080",
    "https://example.com",
    "https://*.example.com",  # Tillåt alla underdomäner till example.com
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

@app.get("/")
async def read_root():
    return {"message": "Hello, World!"}

            

              
                Copy
              
            
          

I detta exempel:

• allow_origins: Specificerar en lista över ursprung som får göra korsursprungsförfrågningar. Att använda ["*"] tillåter alla ursprung, vilket generellt sett inte rekommenderas för produktionsmiljöer. Ange istället de exakta ursprung som ska tillåtas.
• allow_credentials: Indikerar om autentiseringsuppgifter (t.ex. cookies, auktoriseringshuvuden) får inkluderas i korsursprungsförfrågningar. Att ställa in detta till True kräver att huvudet Access-Control-Allow-Origin ställs in på ett specifikt ursprung, inte *.
• allow_methods: Specificerar en lista över HTTP-metoder som är tillåtna för korsursprungsförfrågningar. Att använda ["*"] tillåter alla metoder. Du kan begränsa detta till specifika metoder som ["GET", "POST", "PUT", "DELETE"] för ökad säkerhet.
• allow_headers: Specificerar en lista över HTTP-huvuden som är tillåtna i korsursprungsförfrågningar. Att använda ["*"] tillåter alla huvuden. Överväg att begränsa detta till endast de nödvändiga huvudena för ökad säkerhet.

Bästa metoder för CORS-konfiguration

• Undvik att använda ["*"] för allow_origins i produktion: Detta öppnar ditt API för förfrågningar från vilket ursprung som helst, vilket kan vara en säkerhetsrisk. Lista istället uttryckligen de tillåtna ursprungen.
• Var specifik med tillåtna metoder och huvuden: Tillåt endast de metoder och huvuden som faktiskt behövs av din applikation.
• Förstå konsekvenserna av allow_credentials: Om du tillåter autentiseringsuppgifter, se till att du förstår säkerhetsimplikationerna och konfigurera din server därefter.
• Granska regelbundet din CORS-konfiguration: När din applikation utvecklas kan din CORS-konfiguration behöva uppdateras för att återspegla ändringar i dina tillåtna ursprung, metoder eller huvuden.

Implementera Säkerhetshuvuden

Säkerhetshuvuden är HTTP-svarshuvuden som ger instruktioner till webbläsaren om hur den ska bete sig när den hanterar din webbplats eller ditt API. De hjälper till att mildra olika webbsårbarheter, såsom Cross-Site Scripting (XSS), Clickjacking och andra attacker. Att ställa in dessa huvuden korrekt är avgörande för att skydda din FastAPI-applikation.

Vanliga Säkerhetshuvuden och Deras Betydelse

• Content-Security-Policy (CSP): Detta huvud är ett kraftfullt verktyg för att förhindra XSS-attacker. Det låter dig definiera en vitlista över källor från vilka webbläsaren får ladda resurser som skript, stilmallar och bilder.
• X-Frame-Options: Detta huvud skyddar mot Clickjacking-attacker genom att förhindra att din webbplats bäddas in i en ram på en annan webbplats.
• Strict-Transport-Security (HSTS): Detta huvud tvingar webbläsaren att alltid använda HTTPS när den får åtkomst till din webbplats, vilket förhindrar man-in-the-middle-attacker.
• X-Content-Type-Options: Detta huvud förhindrar webbläsaren från att tolka filer som en annan MIME-typ än den som deklareras i huvudet Content-Type, vilket mildrar MIME-sniffningssårbarheter.
• Referrer-Policy: Detta huvud styr hur mycket hänvisningsinformation (URL:en till den föregående sidan) som skickas med förfrågningar.
• Permissions-Policy (tidigare Feature-Policy): Detta huvud låter dig styra vilka webbläsarfunktioner (t.ex. kamera, mikrofon, geolokalisering) som får användas på din webbplats.

Ställa in Säkerhetshuvuden i FastAPI

Även om FastAPI inte har inbyggd middleware specifikt för att ställa in säkerhetshuvuden, kan du enkelt uppnå detta med hjälp av anpassad middleware eller ett bibliotek från tredje part som starlette-security eller genom att direkt ställa in huvuden i dina svar.

Exempel med hjälp av anpassad middleware:

            
from fastapi import FastAPI, Request, Response
from starlette.middleware import Middleware
from starlette.responses import JSONResponse

app = FastAPI()

async def add_security_headers(request: Request, call_next):
    response: Response = await call_next(request)
    response.headers["Content-Security-Policy"] = "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; object-src 'none'; media-src 'self'; frame-ancestors 'none'; upgrade-insecure-requests; block-all-mixed-content;"
    response.headers["X-Frame-Options"] = "DENY"
    response.headers["X-Content-Type-Options"] = "nosniff"
    response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
    response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains; preload"
    response.headers["Permissions-Policy"] = "geolocation=(), camera=(), microphone=()"
    return response


app.middleware("http")(add_security_headers)


@app.get("/")
async def read_root():
    return {"message": "Hello, World!"}


            

              
                Copy
              
            
          

I detta exempel läggs add_security_headers-middleware till FastAPI-applikationen. Denna middleware fångar upp varje förfrågan och lägger till de specificerade säkerhetshuvudena till svaret. Låt oss bryta ner huvudena:

• Content-Security-Policy: Detta är ett komplext huvud som definierar de tillåtna källorna för olika resurstyper. I det här exemplet tillåter det resurser från samma ursprung ('self'), inline-skript och -stilar ('unsafe-inline' - använd med försiktighet), data-URI:er för bilder (data:) och tillåter inte objekt-element (object-src 'none'). Det ställer också in frame-ancestors 'none' för att förhindra clickjacking. upgrade-insecure-requests talar om för webbläsaren att uppgradera alla osäkra (HTTP) webbadresser till HTTPS. block-all-mixed-content förhindrar webbläsaren från att ladda något blandat innehåll (HTTP-innehåll på en HTTPS-sida). Det är avgörande att anpassa detta huvud för att matcha din specifika applikations behov. Felaktiga CSP-konfigurationer kan förstöra din webbplats.
• X-Frame-Options: Ställs in på DENY för att förhindra att sidan ramas in av någon domän. Alternativt tillåter SAMEORIGIN inramning endast av samma domän.
• X-Content-Type-Options: Ställs in på nosniff för att förhindra MIME-sniffning.
• Referrer-Policy: Ställs in på strict-origin-when-cross-origin för att skicka ursprunget (protokoll + värd) som hänvisning när du navigerar till ett annat ursprung, och ingen hänvisning när du navigerar till samma ursprung.
• Strict-Transport-Security: Ställer in en policy som tvingar webbläsaren att använda HTTPS under en angiven tidsperiod (max-age). includeSubDomains säkerställer att alla underdomäner också skyddas av HTTPS. preload tillåter att domänen inkluderas i HSTS preload-listan, som är inbyggd i webbläsare. Observera att användning av preload kräver att din webbplats har skickats in till och accepterats av HSTS preload-listan.
• Permissions-Policy: Specificerar vilka funktioner (t.ex. geolokalisering, kamera, mikrofon) som får användas i webbläsaren. I det här exemplet är alla otillåtna.

Viktiga överväganden för säkerhetshuvuden:

• Anpassa Content-Security-Policy noggrant: Detta är det mest komplexa säkerhetshuvudet, och det är avgörande att konfigurera det korrekt för att undvika att förstöra din webbplats. Använd en CSP-generator eller -validator för att hjälpa dig att skapa en säker och effektiv policy.
• Testa dina säkerhetshuvuden: Använd onlineverktyg som SecurityHeaders.com för att testa din webbplats säkerhetshuvuden och identifiera eventuella problem.
• Övervaka dina säkerhetshuvuden: Övervaka regelbundet dina säkerhetshuvuden för att säkerställa att de fortfarande är effektiva och att inga ändringar behövs.
• Överväg att använda ett Content Delivery Network (CDN): Många CDN:er erbjuder inbyggda funktioner för hantering av säkerhetshuvuden, vilket kan förenkla processen att ställa in och underhålla dina säkerhetshuvuden.

Utöver CORS och Säkerhetshuvuden

Även om CORS och säkerhetshuvuden är viktiga för API-säkerhet, är de inte de enda åtgärder du bör vidta. Andra viktiga säkerhetsöverväganden inkluderar:

• Autentisering och Auktorisering: Implementera robusta autentiserings- och auktoriseringsmekanismer för att säkerställa att endast behöriga användare kan komma åt ditt API. Överväg att använda OAuth 2.0 eller JWT (JSON Web Tokens) för autentisering.
• Indatavalidering: Validera alla användarindata för att förhindra injektionsattacker (t.ex. SQL-injektion, XSS).
• Hastighetsbegränsning: Implementera hastighetsbegränsning för att förhindra denial-of-service-attacker (DoS).
• Loggning och Övervakning: Logga alla API-förfrågningar och övervaka ditt API för misstänkt aktivitet.
• Regelbundna Säkerhetsrevisioner: Genomför regelbundna säkerhetsrevisioner för att identifiera och åtgärda eventuella sårbarheter.
• Håll Beroenden Uppdaterade: Uppdatera regelbundet din FastAPI-version och alla dess beroenden för att patcha säkerhetssårbarheter.

Slutsats

Att säkra dina FastAPI API:er kräver ett mångfacetterat tillvägagångssätt. Genom att implementera CORS korrekt och ställa in lämpliga säkerhetshuvuden kan du avsevärt minska risken för olika webbsårbarheter. Kom ihåg att regelbundet granska och uppdatera din säkerhetskonfiguration för att hålla jämna steg med utvecklande hot. Att omfamna en omfattande säkerhetsstrategi, inklusive autentisering, indatavalidering, hastighetsbegränsning och övervakning, är avgörande för att bygga robusta och säkra API:er som skyddar dina användare och dina data. Att implementera dessa åtgärder, även om det kan vara komplext, är en nödvändig investering för att säkerställa den långsiktiga säkerheten och stabiliteten för dina applikationer i dagens hotbild.