FastAPI Security: CORS og sikkerhetsoverskrifter for robuste API-er

I dagens sammenkoblede digitale landskap er det avgjørende å sikre API-ene dine. FastAPI, et moderne, høyytelses web-rammeverk for å bygge API-er med Python, tilbyr utmerkede verktøy og funksjoner for å implementere robuste sikkerhetstiltak. Denne omfattende veiledningen dykker ned i to kritiske aspekter ved FastAPI-sikkerhet: Cross-Origin Resource Sharing (CORS) og sikkerhetsoverskrifter. Ved å forstå og implementere disse teknikkene kan du betydelig forbedre beskyttelsen av API-et ditt mot vanlige sårbarheter.

Understanding CORS (Cross-Origin Resource Sharing)

CORS er en nettlesersikkerhetsmekanisme som begrenser websider fra å sende forespørsler til et annet domene enn det som serverte websiden. Denne policyen er på plass for å forhindre at ondsinnede nettsteder får tilgang til sensitive data fra andre nettsteder uten riktig autorisasjon. Uten CORS kan et useriøst nettsted potensielt sende uautoriserte forespørsler til API-et ditt på vegne av en innlogget bruker, noe som kan føre til datainnbrudd eller andre sikkerhetsbrudd.

Why is CORS Necessary?

Se for deg et scenario der en bruker er logget på sin nettbankkonto. Samtidig besøker de et ondsinnede nettsted. Uten CORS kan det ondsinnede nettstedet potensielt utføre JavaScript-kode som sender forespørsler til brukerens bank-API, og overfører midler til angriperens konto. CORS forhindrer dette ved å håndheve en policy for samme opprinnelse som standard.

How CORS Works

Når en nettleser sender en forespørsel på tvers av opprinnelser (en forespørsel til en annen opprinnelse enn gjeldende side), utfører den først en "preflight"-forespørsel ved hjelp av HTTP OPTIONS-metoden. Denne preflight-forespørselen sjekker med serveren for å avgjøre om den faktiske forespørselen er tillatt. Serveren svarer med overskrifter som indikerer hvilke opprinnelser, metoder og overskrifter som er tillatt. Hvis nettleseren fastslår at forespørselen er tillatt basert på serverens svar, fortsetter den med den faktiske forespørselen. Ellers blokkeres forespørselen.

"Opprinnelsen" er definert av protokollen (f.eks. HTTP eller HTTPS), domenet (f.eks. example.com) og porten (f.eks. 80 eller 443). To URL-er anses å ha samme opprinnelse bare hvis alle tre av disse komponentene stemmer nøyaktig.

Configuring CORS in FastAPI

FastAPI forenkler prosessen med å konfigurere CORS ved hjelp av CORSMiddleware. Du kan legge til denne middleware til FastAPI-applikasjonen din for å aktivere CORS og spesifisere de tillatte opprinnelsene, metodene og overskriftene.

Her er et grunnleggende eksempel på hvordan du aktiverer 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",  # Allow all subdomains of 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 dette eksemplet:

• allow_origins: Spesifiserer en liste over opprinnelser som har lov til å sende forespørsler på tvers av opprinnelser. Bruk av ["*"] tillater alle opprinnelser, noe som generelt ikke anbefales for produksjonsmiljøer. Spesifiser heller de nøyaktige opprinnelsene som skal tillates.
• allow_credentials: Indikerer om du vil tillate at legitimasjon (f.eks. informasjonskapsler, autorisasjonsoverskrifter) inkluderes i forespørsler på tvers av opprinnelser. Å sette dette til True krever at Access-Control-Allow-Origin-overskriften settes til en spesifikk opprinnelse, ikke *.
• allow_methods: Spesifiserer en liste over HTTP-metoder som er tillatt for forespørsler på tvers av opprinnelser. Bruk av ["*"] tillater alle metoder. Du kan begrense dette til spesifikke metoder som ["GET", "POST", "PUT", "DELETE"] for større sikkerhet.
• allow_headers: Spesifiserer en liste over HTTP-overskrifter som er tillatt i forespørsler på tvers av opprinnelser. Bruk av ["*"] tillater alle overskrifter. Vurder å begrense dette til bare de nødvendige overskriftene for forbedret sikkerhet.

Best Practices for CORS Configuration

• Unngå å bruke ["*"] for allow_origins i produksjon: Dette åpner API-et ditt for forespørsler fra hvilken som helst opprinnelse, noe som kan være en sikkerhetsrisiko. List heller eksplisitt opp de tillatte opprinnelsene.
• Vær spesifikk med tillatte metoder og overskrifter: Tillat bare metodene og overskriftene som faktisk trengs av applikasjonen din.
• Forstå implikasjonene av allow_credentials: Hvis du tillater legitimasjon, må du sørge for at du forstår sikkerhetsimplikasjonene og konfigurerer serveren din deretter.
• Gjennomgå CORS-konfigurasjonen din regelmessig: Etter hvert som applikasjonen din utvikler seg, kan det hende at CORS-konfigurasjonen din må oppdateres for å gjenspeile endringer i dine tillatte opprinnelser, metoder eller overskrifter.

Implementing Security Headers

Sikkerhetsoverskrifter er HTTP-responsoverskrifter som gir instruksjoner til nettleseren om hvordan den skal oppføre seg når den håndterer nettstedet eller API-et ditt. De hjelper til med å redusere ulike sårbarheter på nettet, som Cross-Site Scripting (XSS), Clickjacking og andre angrep. Å sette disse overskriftene riktig er avgjørende for å beskytte FastAPI-applikasjonen din.

Common Security Headers and Their Importance

• Content-Security-Policy (CSP): Denne overskriften er et kraftig verktøy for å forhindre XSS-angrep. Den lar deg definere en hviteliste over kilder som nettleseren har lov til å laste ressurser fra, for eksempel skript, stilark og bilder.
• X-Frame-Options: Denne overskriften beskytter mot Clickjacking-angrep ved å forhindre at nettstedet ditt blir innebygd i en ramme på et annet nettsted.
• Strict-Transport-Security (HSTS): Denne overskriften tvinger nettleseren til alltid å bruke HTTPS når den får tilgang til nettstedet ditt, og forhindrer man-in-the-middle-angrep.
• X-Content-Type-Options: Denne overskriften forhindrer nettleseren i å tolke filer som en annen MIME-type enn det som er deklarert i Content-Type-overskriften, og reduserer MIME-sniffing-sårbarheter.
• Referrer-Policy: Denne overskriften kontrollerer hvor mye henvisningsinformasjon (URL-en til forrige side) som sendes med forespørsler.
• Permissions-Policy (tidligere Feature-Policy): Denne overskriften lar deg kontrollere hvilke nettleserfunksjoner (f.eks. kamera, mikrofon, geolokalisering) som har lov til å brukes på nettstedet ditt.

Setting Security Headers in FastAPI

Selv om FastAPI ikke har innebygd middleware spesielt for å sette sikkerhetsoverskrifter, kan du enkelt oppnå dette ved hjelp av tilpasset middleware eller et tredjepartsbibliotek som starlette-security eller ved å sette overskrifter direkte i responsene dine.

Example using custom 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 dette eksemplet legges add_security_headers middleware til FastAPI-applikasjonen. Denne middleware fanger opp hver forespørsel og legger til de spesifiserte sikkerhetsoverskriftene i responsen. La oss bryte ned overskriftene:

• Content-Security-Policy: Dette er en kompleks overskrift som definerer de tillatte kildene for forskjellige ressurstyper. I dette eksemplet tillater den ressurser fra samme opprinnelse ('self'), inline-skript og -stiler ('unsafe-inline' - bruk med forsiktighet), data-URIer for bilder (data:) og tillater ikke objekt elementer (object-src 'none'). Den setter også frame-ancestors 'none' for å forhindre clickjacking. upgrade-insecure-requests forteller nettleseren å oppgradere alle usikre (HTTP) URLer til HTTPS. block-all-mixed-content forhindrer nettleseren fra å laste inn blandet innhold (HTTP-innhold på en HTTPS-side). Det er avgjørende å tilpasse denne overskriften for å matche applikasjonens spesifikke behov. Feil CSP-konfigurasjoner kan ødelegge nettstedet ditt.
• X-Frame-Options: Satt til DENY for å forhindre at siden blir rammet inn av et hvilket som helst domene. Alternativt tillater SAMEORIGIN innramming bare av samme domene.
• X-Content-Type-Options: Satt til nosniff for å forhindre MIME-sniffing.
• Referrer-Policy: Satt til strict-origin-when-cross-origin for å sende opprinnelsen (protokoll + host) som henvisning når du navigerer til en annen opprinnelse, og ingen henvisning når du navigerer til samme opprinnelse.
• Strict-Transport-Security: Setter en policy som tvinger nettleseren til å bruke HTTPS i en spesifisert varighet (max-age). includeSubDomains sikrer at alle underdomener også er beskyttet av HTTPS. preload lar domenet inkluderes i HSTS preload-listen, som er innebygd i nettlesere. Vær oppmerksom på at bruk av preload krever at nettstedet ditt er sendt inn til, og akseptert av, HSTS preload-listen.
• Permissions-Policy: Spesifiserer hvilke funksjoner (f.eks. geolokalisering, kamera, mikrofon) som har lov til å brukes i nettleseren. I dette eksemplet er alle ikke tillatt.

Key Considerations for Security Headers:

• Customize Content-Security-Policy carefully: This is the most complex security header, and it's crucial to configure it correctly to avoid breaking your website. Use a CSP generator or validator to help you create a safe and effective policy.
• Test your security headers: Use online tools like SecurityHeaders.com to test your website's security headers and identify any potential issues.
• Monitor your security headers: Regularly monitor your security headers to ensure they are still effective and that no changes are needed.
• Consider using a Content Delivery Network (CDN): Many CDNs offer built-in security header management features, which can simplify the process of setting and maintaining your security headers.

Beyond CORS and Security Headers

While CORS and security headers are essential for API security, they are not the only measures you should take. Other important security considerations include:

• Authentication and Authorization: Implement robust authentication and authorization mechanisms to ensure that only authorized users can access your API. Consider using OAuth 2.0 or JWT (JSON Web Tokens) for authentication.
• Input Validation: Validate all user input to prevent injection attacks (e.g., SQL injection, XSS).
• Rate Limiting: Implement rate limiting to prevent denial-of-service (DoS) attacks.
• Logging and Monitoring: Log all API requests and monitor your API for suspicious activity.
• Regular Security Audits: Conduct regular security audits to identify and address any potential vulnerabilities.
• Keep Dependencies Up-to-Date: Regularly update your FastAPI version and all its dependencies to patch security vulnerabilities.

Conclusion

Securing your FastAPI APIs requires a multi-faceted approach. By implementing CORS correctly and setting appropriate security headers, you can significantly reduce the risk of various web vulnerabilities. Remember to regularly review and update your security configuration to keep pace with evolving threats. Embracing a comprehensive security strategy, including authentication, input validation, rate limiting, and monitoring, is crucial for building robust and secure APIs that protect your users and your data. Implementing these measures, while potentially complex, is a necessary investment to ensure the long-term security and stability of your applications in today's threat landscape.