Otomatisasi Bug Hunting: Cara Membuat Scanner Subdomain dengan Python & FastAPI

Dalam dunia keamanan web (web security) atau program Bug Bounty, tahap reconnaissance (pengumpulan informasi) adalah kunci utama. Sebanyak 80% keberhasilan menemukan celah keamanan (vulnerability) ditentukan dari seberapa teliti kita memetakan target. Namun, mengecek puluhan atau bahkan ratusan subdomain secara manual satu per satu adalah pekerjaan yang sangat tidak efisien dan melelahkan.

Sebagai programmer, solusi terbaik untuk masalah ini adalah dengan membangun **automation tools** sendiri. Di artikel ini, gue akan membagikan cara mendesain scanner subdomain dan detektor broken link (seperti yang gue implementasikan pada tools BLH-hunter) menggunakan **Python** dan **FastAPI**.

Mengapa Python dan FastAPI?

Python adalah bahasa standar untuk penulisan skrip keamanan karena ekosistem pustakanya (library) yang sangat lengkap untuk urusan networking dan DNS. Di sisi lain, FastAPI adalah pilihan terbaik untuk mengekspos skrip Python tersebut menjadi HTTP API yang cepat, asinkron, dan mudah dihubungkan dengan UI dashboard modern.

Langkah 1: Membuat Pemindai Resolusi DNS

Langkah dasar dari scanning subdomain adalah memverifikasi apakah subdomain tersebut aktif dan mengarah ke IP publik tertentu. Kita bisa menggunakan pustaka dnspython untuk melakukan query resolusi DNS:

import dns.resolver

def resolve_subdomain(subdomain):
    try:
        answers = dns.resolver.resolve(subdomain, 'A')
        ips = [answer.to_text() for answer in answers]
        return {"active": True, "ips": ips}
    except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
        return {"active": False, "ips": []}
    except Exception as e:
        return {"active": False, "error": str(e)}

Langkah 2: Pemindaian Asinkron dengan HTTPX

Untuk mendeteksi kerentanan seperti **Broken Link Hijacking (BLH)**, kita harus mengecek respon HTTP dari target. Jika target mengarah ke layanan pihak ketiga (seperti GitHub Pages, Medium, atau AWS S3) yang sudah tidak aktif (status 404), penyerang berpotensi mengambil alih link tersebut.

Menggunakan pustaka httpx secara asinkron memungkinkan kita mengirimkan puluhan permintaan secara paralel untuk performa maksimal:

import httpx
import asyncio

async def check_status(client, url):
    try:
        # Kirim GET request dengan timeout rendah
        response = await client.get(url, timeout=5.0, follow_redirects=True)
        return {
            "url": url,
            "status_code": response.status_code,
            "server": response.headers.get("Server", "Unknown")
        }
    except httpx.RequestError:
        return {"url": url, "status_code": 0, "error": "Connection Failed"}

async def scan_bulk(urls):
    async with httpx.AsyncClient() as client:
        tasks = [check_status(client, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

Langkah 3: Menyajikan Data dengan FastAPI

Setelah modul pemindai siap, kita bisa membungkusnya ke dalam endpoint API menggunakan FastAPI. API ini nantinya memicu proses scanning dan mengembalikan hasilnya dalam format JSON untuk dirender di dashboard frontend:

from fastapi import FastAPI, BackgroundTasks
from pydantic import BaseModel
from typing import List

app = FastAPI(title="Recon Workspace")

class ScanRequest(BaseModel):
    target_domain: string
    subdomains: List[str]

# Database lokal tiruan untuk menyimpan hasil
scan_db = {}

def run_background_scan(target: str, subdomains: List[str]):
    # Logika eksekusi resolver & checker
    results = []
    for sub in subdomains:
        full_url = f"https://{sub}.{target}"
        # Panggil fungsi check_status secara sinkron atau dengan loop event
        # Simpan ke scan_db
        pass

@app.post("/api/scan")
def trigger_scan(req: ScanRequest, bg_tasks: BackgroundTasks):
    bg_tasks.add_task(run_background_scan, req.target_domain, req.subdomains)
    return {"status": "scanning", "message": "Scan started in background."}

@app.get("/api/results/{target}")
def get_results(target: str):
    return scan_db.get(target, {"status": "no_data", "results": []})

Impak Dunia Nyata: Mendapatkan NASA LoR

Dengan membuat tools pemindai otomatis, kita bisa membiarkan program bekerja di cloud VPS secara terus-menerus. Pada proyek BLH-hunter, scanner asinkron ini berhasil memetakan ratusan subdomain target dalam hitungan menit dan mendeteksi beberapa broken social link valid yang terlupakan di sistem internal NASA.

Laporan yang detail dan terstruktur dikirimkan melalui program VDP (Vulnerability Disclosure Program) mereka, dan hanya dalam hitungan minggu, penghargaan resmi berupa NASA Letter of Recognition berhasil diamankan.

Kesimpulan

Otomatisasi adalah pembeda utama antara bug hunter pemula dan profesional. Dengan meluangkan waktu sejenak menulis script otomasi menggunakan Python dan menyajikannya dalam dashboard FastAPI, Anda menghemat ribuan jam kerja manual dan melipatgandakan peluang menemukan celah keamanan sebelum orang lain.

Commit. Push. Repeat.