Belajar FastAPI - Security Best Practices

#Pendahuluan

Setelah di episode 17 API kita punya error handling dan logging yang rapi, sekarang kita rangkai semuanya menjadi satu tema: keamanan. Selama 17 episode kita sudah menabur kebiasaan yang benar — validasi Pydantic, parameterized query, bcrypt, JWT — episode ini merangkumnya menjadi peta pertahanan berlapis, plus menutup celah yang belum dibahas.

Mengapa episode ini penting? Karena kebanyakan serangan tidak canggih — mereka mengeksploitasi hal-hal dasar: query yang dirangkai string, input yang tidak divalidasi, header yang hilang. Pertahanan yang benar dimulai dari menghilangkan celah dasar, bukan memasang "alarm super mahal" di atas celah yang masih terbuka.

#Prinsip Pertahanan Berlapis

Keamanan bekerja berlapis — jika satu lapis tembus, lapis berikutnya masih menahan:

#SQL Injection: Parameterized Query

SQL Injection terjadi saat input user dirangkai langsung ke query SQL. Contoh rentan (jangan ditiru):

VULNERABLE - jangan ditiru

@app.get("/items/")
def search(name: str, db: Session = Depends(get_db)) -> list:
    query = f"SELECT * FROM items WHERE name = '{name}'"
    return db.execute(text(query)).all()

Input ' OR '1'='1 akan membuat query mengembalikan seluruh tabel. Pertahanannya: selalu parameterized. Dengan SQLAlchemy ORM:

Aman - parameterized via ORM

from sqlalchemy import select
 
@app.get("/items/")
def search(name: str, db: Session = Depends(get_db)) -> list:
    statement = select(models.Item).where(
        models.Item.name == name
    )
    return db.execute(statement).scalars().all()

ORM where(models.Item.name == name) mengirim name sebagai parameter terikat, bukan string yang di-splice — nilai input tidak pernah ditafsirkan sebagai SQL.

#XSS: Jangan Percaya Output

XSS (Cross-Site Scripting) terjadi saat input user di-render sebagai HTML/JS. FastAPI sebagai pure API lebih kebal, karena ia mengirim JSON, bukan HTML. Tapi dua jalur tetap perlu dijaga:

1. Jika kalian mengembalikan HTML (via HTMLResponse), escape semua input yang di-render.
2. Klien frontend harus menganggap semua field JSON sebagai data, bukan HTML — tanggung jawab bersama.

Untuk input teks yang disimpan lalu ditampilkan, validasi di Pydantic membantu membatasi pola berbahaya:

Validasi input teks

import re
 
from pydantic import BaseModel, field_validator
 
 
class CommentCreate(BaseModel):
    body: str
 
    @field_validator("body")
    @classmethod
    def batasi_script(cls, v: str) -> str:
        if re.search(r"<script", v, re.IGNORECASE):
            raise ValueError("teks mengandung tag terlarang")
        return v

Pola field_validator ini adalah bentuk validasi domain yang kita bangun di episode 5 — sekarang dipakai sebagai gerbang keamanan.

#CSRF: Mengenal Sumber Request

CSRF mengeksploitasi cookie session: situs jahat memaksa browser korban mengirim request ke API kita dengan cookie otomatis. Mitigasi utamanya:

• Jangan andalkan cookie untuk mutasi data; pakai Authorization header (seperti JWT kita di episode 12). Header tidak dikirim otomatis oleh browser pihak ketiga.
• Jika cookie tetap dipakai, pasang anti-CSRF token dan verifikasi Origin/Referer.

Karena FastAPI auth kita berbasis Bearer token (bukan cookie), serangan CSRF klasik otomatis netral. Ini salah satu alasan pola episode 12 bagus.

#Security Headers

Header keamanan memberitahu browser cara memperlakukan response. Gunakan SecureHeadersMiddleware (library secure) atau tulis manual:

pip install secure

Security headers middleware

from secure import SecureHeaders
from starlette.middleware.base import BaseHTTPMiddleware
from fastapi import FastAPI, Request
 
secure_headers = SecureHeaders()
 
 
class SecurityHeadersMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        response = await call_next(request)
        secure_headers.set_headers(response.headers)
        return response
 
 
app = FastAPI()
app.add_middleware(SecurityHeadersMiddleware)

Header yang dihasilkan meliputi:

Semua ini gratis untuk dipasang dan menutup banyak kelas serangan browser — kombinasikan dengan CORS yang sudah benar dari episode 11.

#Dependency Security

Aplikasi seaman dependensinya. Library dengan kerentanan adalah backdoor diam-diam. Audit rutin:

pip install pip-audit
pip-audit

pip-audit membandingkan package terinstall dengan database CVE. Di CI (episode 24), jadikan ini langkah wajib sebelum build:

pip-audit -o audit.json --fail-on any

#Ringkasan Pertahanan Berlapis FastAPI

#Common Pitfalls

#Penutup

Inti yang harus dibawa pulang:

• SQLi: parameterized query — tidak pernah menyusun SQL dari string user.
• XSS: escape output HTML; frontend harus memperlakukan data sebagai data.
• CSRF: Bearer token di header menetralkan serangan cookie-based.
• Pasang security headers dan audit dependency (pip-audit) di CI.

Di episode 19 selanjutnya kita akan membahas rate limiting & DoS protection — melindungi API dari banjir request dengan slowapi, throttling per-IP dan per-user, serta konfigurasi reverse proxy untuk mencegah DoS. Pertahanan kalian kini berlapis dari jaringan sampai aplikasi!