Muhammad Fari Madyan
Hire me
Spring Boot · bagian 5 dari 8

Java Spring Boot + React E-Learning Part 5: Audit Keamanan Kedua — Rotasi Refresh Token, Wajib Ganti Password & Otorisasi STOMP

Audit kedua dengan sudut pandang penyerang terhadap platform CBT Spring Boot 3 + React 19 yang sudah live: IP klien yang bisa dipalsukan, map rate limit tanpa batas, refresh token yang bisa diputar ulang, JWT secret yang ter-commit, download file publik, dan subscription WebSocket yang bisa disalahgunakan guru mana pun, lengkap dengan perbaikan dari PR #5 dan PR #6.

Muhammad Fari Madyan

· 16 menit baca

Read in English →

Pendahuluan: Mengaudit Kode Sendiri Setelah Live

Di akhir Part 4, platform ini akhirnya bisa diakses di https://spring-elearning.mfarim.com. Jujur, waktu itu saya merasa sudah sampai di garis finis. Ternyata belum.

Repositori mfarim/spring-elearning-react sengaja saya buat publik. Artinya, siapa pun bisa membaca application.yml, data seed, konfigurasi WebSocket, sampai README yang mencantumkan akun demo. Dari situ saya sadar perlu audit kedua dengan satu asumsi yang lebih jujur: penyerang sudah membaca semua file di repo saya. Begitu saya pakai kacamata itu, beberapa pertahanan yang saya banggakan di Part 2 dan Part 3 ternyata tidak sekuat yang saya kira.

Semua perbaikannya saya masukkan lewat dua pull request:

Di artikel ini saya ajak kamu menelusuri temuan itu satu per satu: bagaimana celahnya bisa disalahgunakan, lalu kode yang saya pakai untuk menutupnya.

Lapisan pertahanan setelah audit keamanan kedua

Klik diagram untuk membukanya dalam ukuran penuh.


1. Ringkasan Temuan

#TemuanDampakDiperbaiki di
1CORS memblokir origin produksi; perbaikan pertama fallback ke * dengan credentialsProduksi rusak, lalu fallback terlalu longgarPR #5, PR #6
2IP klien dibaca dari CF-Connecting-IP / X-Forwarded-ForRate limit tembus dengan satu headerPR #6
3Bucket rate limit disimpan di ConcurrentHashMap tanpa batasHeap habis dengan merotasi IP atau emailPR #6
4Login sukses me-reset bucket IPPenyerang me-reset limitnya sendiri dengan loginPR #6
5Refresh token stateless, dan diterima sebagai access tokenLogout tidak nyata; token curian bisa dipakai 7 hariPR #6
6JWT_SECRET default ter-commit di application.ymlSiapa pun bisa memalsukan token di deploy yang salah konfigurasiPR #6
7Akun seed memakai password yang terdokumentasiPengambilalihan akun di instance yang masih memakai seedPR #6
8/api/v1/files/** berstatus permitAll()Siapa pun yang punya URL bisa mengunduh tugas siswaPR #6
9STOMP: guru mana pun bisa memantau ujian mana pun, wildcard diizinkan, klien bisa SEND ke /topicKebocoran data dan event proctoring palsuPR #6
10Swagger aktif, log DEBUG, password DB kosong diizinkan di produksiKebocoran informasi, default yang lemahPR #6

2. CORS: Perbaikan yang Perlu Diperbaiki (PR #5)

Awalnya SecurityConfig saya isi origin localhost secara hardcode, jadi domain produksi justru terblokir. Di PR #5 saya membuat daftarnya bisa diatur lewat APP_CORS_ALLOWED_ORIGINS dan beralih ke setAllowedOriginPatterns. Masalahnya, saya juga menambahkan fallback ini:

JAVA
// PR #5 (terlalu longgar)
configuration.setAllowedOriginPatterns(allowedOrigins != null && !allowedOrigins.isEmpty()
        ? allowedOrigins : List.of("*"));
configuration.setAllowCredentials(true);

Coba perhatikan: * yang digabung dengan allowCredentials(true) berarti situs mana pun boleh memanggil API dengan kredensial user, asalkan suatu hari variabelnya kosong. Di PR #6 wildcard itu saya hapus. Sekarang, daftar kosong berarti hanya same-origin yang diizinkan.

JAVA
// PR #6: tanpa fallback wildcard, daftar kosong berarti same-origin saja
configuration.setAllowedOriginPatterns(allowedOrigins == null ? List.of()
        : allowedOrigins.stream().map(String::trim).filter(o -> !o.isEmpty()).toList());

Pelajaran yang saya ambil: nilai default konfigurasi harus fail closed. Kalau suatu saat saya (atau kamu) lupa mengisi variabel, aplikasi harus jadi lebih ketat, bukan malah lebih longgar.


3. IP Klien yang Asli: Satu Header Mengalahkan Rate Limiter

Di Part 3, rate limiter saya memakai IP klien sebagai kunci bucket. Begini cara saya menentukan IP itu waktu itu:

JAVA
// Sebelum PR #6: mempercayai header yang dikendalikan klien
public static String getClientIp(HttpServletRequest request) {
    String ip = request.getHeader("CF-Connecting-IP");
    if (ip == null || ip.isBlank() || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getHeader("X-Forwarded-For");
        // ... entri pertama dari daftar
    }
    // ... X-Real-IP, lalu getRemoteAddr()
    return ip;
}

Masalahnya, semua header itu bisa dikirim sendiri oleh klien. Skrip brute force cukup menambahkan IP acak di setiap request:

BASH
for i in $(seq 1 1000); do
  curl -s -X POST https://target/api/v1/auth/login \
    -H "X-Forwarded-For: 10.0.$((i / 255)).$((i % 255))" \
    -H "Content-Type: application/json" \
    -d '{"email":"[email protected]","password":"guess'$i'"}'
done

Setiap request jadi masuk ke bucket baru, sehingga aturan "5 percobaan per menit per IP" yang saya buat tidak pernah terpicu sama sekali.

Perbaikannya: tentukan IP sekali di edge, dan hanya percayai proxy internal

Untungnya, Spring Boot bisa menyerahkan urusan ini ke RemoteIpValve milik Tomcat:

YAML
server:
  # Ambil IP klien dari X-Forwarded-For HANYA jika request datang dari proxy internal yang dipercaya
  # (Tomcat RemoteIpValve). Range default: 10/8, 172.16/12, 192.168/16, 169.254/16 dan 127/8,
  # yaitu container nginx di jaringan Docker.
  forward-headers-strategy: native

Valve ini membaca X-Forwarded-For dari kanan ke kiri dan berhenti di alamat pertama yang bukan proxy internal tepercaya. Apa pun yang diselipkan klien di depan header akan diabaikan. Hasilnya, kode aplikasi saya jadi jauh lebih sederhana:

JAVA
public static String getClientIp(HttpServletRequest request) {
    return request.getRemoteAddr(); // sudah ditentukan oleh RemoteIpValve
}

Karena situs saya ada di belakang Cloudflare, masih ada satu langkah lagi. Tanpa langkah ini, semua pengunjung terlihat memakai IP Cloudflare dan semua user berbagi bucket yang sama. Perbaikannya cukup dua direktif di Nginx host dari Part 4: pulihkan IP pengunjung, lalu timpa header-nya, jangan ditambahkan:

NGINX
# /etc/nginx/sites-available/spring-elearning (host Nginx)
set_real_ip_from 173.245.48.0/20;   # ...tambahkan semua range IPv4/IPv6 Cloudflare
real_ip_header CF-Connecting-IP;

location / {
    proxy_pass http://127.0.0.1:8088;
    proxy_set_header X-Forwarded-For $remote_addr;   # sebelumnya $proxy_add_x_forwarded_for
}

set_real_ip_from hanya menerima CF-Connecting-IP dari range IP Cloudflare. Jadi, klien yang terhubung langsung ke VPS pun tidak bisa ikut memalsukan header itu.


4. Bucket Berbatas dan Reset yang Lebih Cerdas

Masalah kedua di limiter Part 3 adalah memori. Saya menyimpan satu Bucket per IP dan per email di ConcurrentHashMap, selamanya. Kalau ada yang merotasi email palsu, map itu akan terus membesar sampai heap JVM habis. Di PR #6 semua map bucket saya pindahkan ke cache Caffeine yang punya batas ukuran dan bisa kedaluwarsa:

JAVA
// LoginRateLimiterService (PR #6)
static Cache<String, Bucket> newBucketCache() {
    return Caffeine.newBuilder()
            .maximumSize(100_000)
            .expireAfterAccess(Duration.ofMinutes(10))
            .build();
}

Factory yang sama saya pakai untuk tiga tingkat di RateLimitingFilter: auth 10, submit ujian 60, dan umum 120 request per menit per IP.

Ternyata ada juga bug logika. Setelah login sukses, saya menghapus bucket IP dan bucket email sekaligus. Akibatnya, penyerang yang punya akun valid bisa login setiap beberapa percobaan untuk terus me-reset limit IP-nya. Sekarang yang saya hapus hanya bucket akun:

JAVA
/**
 * Dipanggil setelah login sukses. Hanya bucket per akun yang di-reset; bucket per IP dipertahankan,
 * kalau tidak penyerang bisa me-reset limit IP-nya dengan login berkala ke akunnya sendiri.
 */
public void clearRateLimit(String clientIp, String email) {
    if (email != null) {
        emailBuckets.invalidate(email.trim().toLowerCase());
    }
}

Di Part 7, limiter ini saya beri interface dengan implementasi Redis supaya beberapa instance backend bisa berbagi penghitung yang sama.


5. Higiene JWT: Tipe Token dan Secret yang Tidak Diketahui Siapa Pun

Di JwtProvider saya menemukan dua masalah.

Refresh token bisa dipakai sebagai access token. Kedua jenis token saya tanda tangani dengan kunci yang sama, dan bentuknya pun sama. Filter hanya memeriksa signature dan masa berlaku, jadi refresh token 7 hari bisa dikirim sebagai Authorization: Bearer dan tetap diterima. Sekarang setiap token membawa claim typ, dan setiap pintu masuk memeriksanya:

JAVA
public static final String CLAIM_TYPE = "typ";
public static final String TYPE_ACCESS = "access";
public static final String TYPE_REFRESH = "refresh";

/** Signature valid, belum kedaluwarsa, dan typ=access. Refresh token ditolak. */
public boolean validateAccessToken(String token) {
    Claims claims = parseClaims(token);
    return claims != null && TYPE_ACCESS.equals(claims.get(CLAIM_TYPE, String.class));
}

Kunci penanda tangan ada di repo. application.yml saya berisi secret: ${JWT_SECRET:dGhpcy1pcy1h...}. Artinya, deploy yang lupa mengisi JWT_SECRET diam-diam memakai kunci yang sudah terpampang di GitHub, dan siapa pun bisa membuat token admin. Nilai default itu sudah saya hapus. Nilai yang sudah telanjur publik juga saya tolak, meskipun seseorang menyalinnya ke .env:

JAVA
private static final Set<String> KNOWN_PUBLIC_SECRETS = Set.of(
        "dGhpcy1pcy1hLXZlcnktc2VjdXJlLTI1Ni1iaXQtbG9uZy1zZWNyZXQta2V5LWZvci1qd3Qtc2lnbmluZw=="
);

if (KNOWN_PUBLIC_SECRETS.contains(secret.trim())) {
    throw new IllegalStateException("CRITICAL: app.jwt.secret uses a publicly known example value. "
            + "Generate a new one with: openssl rand -base64 32");
}

Docker Compose menerapkan aturan yang sama, bahkan sebelum JVM sempat berjalan:

YAML
JWT_SECRET: ${JWT_SECRET:?JWT_SECRET is required (openssl rand -base64 32)}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD is required}

6. Rotasi Refresh Token di Sisi Server

Di Part 2 saya memang sudah menambahkan refresh token, tetapi sepenuhnya stateless. "Logout" cuma menghapusnya dari browser, sementara refresh token yang telanjur tersalin tetap berlaku selama 7 hari. Di PR #6, setiap refresh token saya daftarkan di Redis berdasarkan jti (JWT ID):

JAVA
@Service
@RequiredArgsConstructor
public class RefreshTokenStore {

    private static final String TOKEN_KEY = "auth:refresh:";
    private static final String USER_KEY = "auth:refresh:user:";

    private final StringRedisTemplate redis;

    public void store(String jti, Long userId, Duration ttl) {
        redis.opsForValue().set(TOKEN_KEY + jti, userId.toString(), ttl);
        redis.opsForSet().add(USER_KEY + userId, jti);
        redis.expire(USER_KEY + userId, ttl);
    }

    /** Menghapus jti secara atomik. True hanya jika jti ada dan milik user tersebut. */
    public boolean consume(String jti, Long userId) {
        String owner = redis.opsForValue().getAndDelete(TOKEN_KEY + jti);
        redis.opsForSet().remove(USER_KEY + userId, jti);
        return owner != null && owner.equals(userId.toString());
    }

    /** Mencabut semua refresh token milik user (ganti password, akun dibobol). */
    public void revokeAll(Long userId) { /* hapus setiap jti di auth:refresh:user:{id} */ }
}

getAndDelete dipetakan ke perintah Redis GETDEL yang atomik. Jadi, dua request dengan refresh token yang sama tidak mungkin sama-sama berhasil: satu mendapat user ID, yang lain mendapat null. Di service, perilaku itu saya ubah menjadi rotasi:

JAVA
// AuthService.refreshToken
Long userId = Long.parseLong(claims.getSubject());
// Rotasi: setiap refresh token hanya bisa dipakai sekali; token yang dicabut/dipakai ulang ditolak.
if (!refreshTokenStore.consume(claims.getId(), userId)) {
    throw new BadCredentialsException("Refresh token has been revoked or already used");
}
// ...cek user masih aktif, lalu terbitkan pasangan access + refresh baru

Dengan perubahan ini, saya mendapat beberapa hal sekaligus:

  • Logout jadi sungguhan. POST /auth/logout mencabut jti.
  • Ganti password me-logout semua perangkat. changePassword memanggil revokeAll(userId), lalu menerbitkan satu pasangan token baru untuk sesi saat ini.
  • Pemakaian ulang ketahuan. Kalau penyerang melakukan refresh lebih dulu, refresh berikutnya dari klien yang sah akan gagal dan user diarahkan ke halaman login. Ini sinyal yang kelihatan, bukan pengambilalihan diam-diam.
  • Access token tetap stateless. Hanya endpoint refresh yang menyentuh Redis; panggilan API biasa tidak.

Supaya frontend ikut bekerja, saya perlu dua perubahan kecil. SecurityConfig sekarang mengembalikan 401 untuk token yang hilang atau kedaluwarsa (bukan 403 bawaan) sehingga Axios tahu kapan harus refresh. Lalu JwtAuthenticationFilter menolak user yang dinonaktifkan atau dikunci, meskipun tokennya belum kedaluwarsa.

Sampai tahap ini refresh token masih saya kirim di body JSON dan disimpan di localStorage. Di Part 7, saya memindahkannya ke cookie httpOnly.


7. Wajib Ganti Password untuk Akun Seed

Migrasi seed saya membuat akun admin, guru, dan siswa dengan password password, dan README mencantumkan akun-akun itu supaya orang bisa mencoba demo. Untuk demo, itu tidak masalah. Namun, kalau dipakai sekolah sungguhan, itu sama saja dengan membiarkan pintu terbuka.

Di PR #6 saya menambahkan sebuah flag dan menyalakannya untuk setiap akun yang masih memakai hash yang terdokumentasi:

SQL
-- V2__security_hardening.sql
ALTER TABLE users ADD COLUMN must_change_password BOOLEAN NOT NULL DEFAULT FALSE;

UPDATE users
SET must_change_password = TRUE
WHERE password = '$2a$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi';

Lalu ada filter yang berjalan tepat setelah autentikasi dan memblokir semuanya, kecuali alur ganti password:

JAVA
public class PasswordChangeRequiredFilter extends OncePerRequestFilter {

    private static final Set<String> ALLOWED_PATHS = Set.of(
            "/api/v1/auth/me", "/api/v1/auth/change-password", "/api/v1/auth/logout",
            "/api/v1/auth/refresh", "/api/v1/auth/login", "/api/v1/admin/stop-impersonate");

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (!demoMode && auth != null
                && auth.getPrincipal() instanceof UserPrincipal principal
                && principal.isMustChangePassword()
                && principal.getImpersonatorAdminId() == null
                && request.getRequestURI().startsWith("/api/")
                && !ALLOWED_PATHS.contains(request.getRequestURI())) {
            response.setStatus(HttpStatus.FORBIDDEN.value());
            // {"success":false,"code":"PASSWORD_CHANGE_REQUIRED", ...}
            return;
        }
        chain.doFilter(request, response);
    }
}

Ada beberapa detail yang menurut saya penting:

  • Filter saya daftarkan dengan addFilterAfter(..., UsernamePasswordAuthenticationFilter.class), jadi user sudah dikenali lebih dulu.
  • Admin yang sedang impersonasi tidak diblokir. Kalau diblokir, dukungan teknis jadi mustahil.
  • Demo publik memakai APP_DEMO_MODE=true. Mode ini melewati aturan tadi dan mematikan ganti password, supaya pengunjung demo tidak saling mengunci akun.
  • Password baru tidak boleh sama dengan yang lama, atau dengan salah satu default yang terdokumentasi (password, Student@123, Teacher@123).
  • Di frontend, ProtectedRoute mengarahkan user dengan mustChangePassword ke halaman baru /change-password.

Registrasi mandiri juga saya jadikan opsional, dengan APP_REGISTRATION_ENABLED=false sebagai default, karena di sekolah akun dibuat lewat panel admin.


8. File: Dari URL Publik ke Otorisasi per Objek

Nah, ini temuan yang paling serius. SecurityConfig saya berisi:

JAVA
.requestMatchers("/api/v1/auth/**", "/api/v1/files/**", /* swagger... */).permitAll()

Nama file memang berupa UUID acak, jadi URL-nya sulit ditebak. Namun, setiap URL yang muncul di halaman, log, atau screenshot yang dibagikan memberi akses anonim permanen ke tugas siswa. Di PR #6, /api/v1/files/** saya hapus dari daftar publik, lalu saya tambahkan service otorisasi khusus:

JAVA
/**
 * - submissions/**: admin, siswa yang mengumpulkan, atau guru pemilik tugas
 * - materials/**:   admin/guru, atau siswa dari kelas tujuan jika materi sudah dipublikasikan
 * - lainnya:        hanya admin/guru
 */
@Transactional(readOnly = true)
public boolean canRead(String filePath, UserPrincipal principal) {
    if (filePath.startsWith("submissions/")) {
        Optional<AssignmentSubmission> submission = submissionRepository.findFirstByFilePath(filePath);
        // ...siswa pemilik, guru pemilik, atau admin
    }
    if (filePath.startsWith("materials/")) {
        // ...sudah dipublikasikan, dan kelas siswa cocok (atau materi untuk semua kelas)
    }
    return isAdmin || isTeacher;
}

Saat akses ditolak, FileController menjawab 404, bukan 403. Dengan begitu, user yang iseng mencoba-coba tidak bisa tahu apakah file itu ada. Download juga saya beri Cache-Control: private, no-store supaya proxy bersama atau cache browser tidak menyimpan salinannya.

Karena download sekarang butuh header Authorization, <a href> biasa tidak bisa dipakai lagi. Jadi frontend saya mengambil file sebagai blob dengan token, lalu membukanya di tab baru:

TYPESCRIPT
export async function openProtectedFile(url: string): Promise<void> {
  // Buka tab secara sinkron (di dalam click handler) agar tidak diblokir popup blocker.
  const win = window.open('', '_blank');
  try {
    const response = await api.get<Blob>(url.replace(/^\/api\/v1/, ''), { responseType: 'blob' });
    const blobUrl = URL.createObjectURL(response.data);
    if (win) {
      win.opener = null;
      win.location.href = blobUrl;
    }
    setTimeout(() => URL.revokeObjectURL(blobUrl), 60_000);
  } catch (err) {
    win?.close();
    throw err;
  }
}

Perhatikan bahwa tab kosong saya buka sebelum await. Browser hanya mengizinkan window.open selama event klik berlangsung, dan await akan mendorongnya keluar dari momen itu.


9. WebSocket: Otorisasi STOMP Deny-by-Default

Monitor ujian live memakai STOMP di atas WebSocket. Interceptor awal saya mengautentikasi CONNECT, tapi untuk SUBSCRIBE aturannya cuma satu:

JAVA
// Sebelum PR #6
if (destination.startsWith("/topic/exams/") && destination.endsWith("/monitor")) {
    boolean canMonitor = authorities.anyMatch(a -> a.equals("ROLE_ADMIN") || a.equals("ROLE_TEACHER"));
    if (!canMonitor) throw new AccessDeniedException("Forbidden");
}

Dari situ ada tiga celah yang tersisa:

  1. Guru mana pun bisa memantau ujian mana pun, termasuk kelas sekolah lain di instance yang sama. Aturannya memeriksa role, bukan kepemilikan.
  2. Wildcard lolos. Simple broker Spring mendukung subscription berpola, jadi SUBSCRIBE /topic/** tidak cocok dengan aturan di atas dan malah menerima semua event dari semua ujian.
  3. Klien bisa SEND langsung ke /topic/..., lalu menyuntikkan event EXAM_SUBMITTED atau VIOLATION_REPORTED palsu ke monitor guru.

Interceptor yang baru menangani setiap perintah secara eksplisit dan menolak apa pun yang tidak dikenal:

JAVA
switch (accessor.getCommand()) {
    case CONNECT, STOMP -> authenticate(accessor);   // validateAccessToken + user aktif
    case SUBSCRIBE -> authorizeSubscribe(accessor);
    case SEND -> authorizeSend(accessor);
    default -> { /* DISCONNECT, UNSUBSCRIBE, ACK, ... */ }
}

private void authorizeSubscribe(StompHeaderAccessor accessor) {
    UserPrincipal user = requireUser(accessor.getUser());
    String destination = accessor.getDestination();

    // Deny-by-default. Subscription berpola ditolak karena simple broker
    // akan mengirim semua destination yang cocok.
    if (destination == null || destination.contains("*") || destination.contains("{") || destination.contains("?")) {
        throw deny(user, destination);
    }

    Matcher monitor = EXAM_MONITOR_DESTINATION.matcher(destination);   // ^/topic/exams/(\d+)/monitor$
    if (monitor.matches()) {
        Long examId = Long.valueOf(monitor.group(1));
        boolean isAdmin = hasRole(user, "ROLE_ADMIN");
        boolean isOwnerTeacher = hasRole(user, "ROLE_TEACHER")
                && examinationRepository.existsByIdAndTeacher_User_Id(examId, user.getId());
        if (!isAdmin && !isOwnerTeacher) throw deny(user, destination);
        return;
    }

    if (USER_QUEUE_DESTINATION.matcher(destination).matches()) return;   // /user/queue/...

    throw deny(user, destination);
}

private void authorizeSend(StompHeaderAccessor accessor) {
    // Klien hanya boleh mengirim ke handler aplikasi (/app/**), tidak pernah langsung ke broker.
    if (destination == null || !destination.startsWith("/app/")) throw deny(user, destination);
}
DestinationSiapa yang boleh subscribe atau send
/topic/exams/{id}/monitorSubscribe: guru pemilik ujian {id}, atau admin
/user/queue/**Subscribe: user yang terautentikasi (di-resolve Spring per sesi)
/app/**Send: user terautentikasi mana pun; ditangani kode @MessageMapping
Apa pun yang mengandung *, {, ?Tidak ada
Selain ituTidak ada

CONNECT juga sekarang memakai validateAccessToken, jadi refresh token tidak bisa membuka socket, dan user yang dihapus atau nonaktif langsung ditolak.


10. Penguatan Operasional

Di PR yang sama, saya juga membereskan beberapa hal kecil yang mengurangi apa yang bisa dipelajari atau dieksploitasi penyerang:

AreaPerubahan
Dokumentasi APISPRINGDOC_ENABLED=false sebagai default di docker-compose.prod.yml
Loggingcom.elearning di ${LOG_LEVEL_APP:INFO}, bukan DEBUG
Nginx (container SPA)server_tokens off, Permissions-Policy: camera=(), microphone=(), geolocation=(), payment=()
Header lawasX-XSS-Protection: 0: XSS auditor lama sudah dihapus dari browser modern dan bisa disalahgunakan untuk kebocoran lintas situs
RuntimeSpring Boot 3.5.7, Node 22 untuk build frontend
Supply chainDependabot untuk Maven, npm, image Docker, dan GitHub Actions
Deploydeploy.sh: git pull, build semua service atau satu (./deploy.sh backend --no-cache), up -d, hapus image lama

11. Sebelum dan Sesudah

AreaSetelah Part 3Setelah PR #6
IP klienNilai pertama dari header yang dikendalikan klienRemoteIpValve, hanya proxy tepercaya
Memori rate limitMap tanpa batasCaffeine, maks 100 ribu key, kedaluwarsa 10 menit
Refresh tokenStateless, berlaku 7 hari, bisa jadi access tokenjti sekali pakai di Redis, claim typ diperiksa
LogoutHanya di sisi klienDicabut di server; cabut semua saat ganti password
JWT secretNilai default di application.ymlWajib diisi; nilai publik ditolak
Password seedBisa dipakai selamanyaWajib diganti saat login pertama (kecuali demo)
Download fileURL publikOtorisasi per objek, 404 saat ditolak
STOMPCek role di satu polaDeny by default, cek kepemilikan, tanpa wildcard, tanpa SEND langsung

Kesimpulan & Selanjutnya

Kalau saya renungkan, audit pertama bertanya "apakah setiap fitur punya kontrol keamanan?", sedangkan audit kedua bertanya "bisakah orang yang sudah membaca kodenya melewati kontrol itu?". Pertanyaan kedua inilah yang menemukan header yang bisa dipalsukan, map tanpa batas, secret yang ter-commit, dan route file publik. Tidak satu pun akan tertangkap kalau saya hanya mencentang checklist fitur.

Selama menulis perbaikan ini, saya juga melihat celah yang tidak bisa ditutup dengan kerja keamanan: kebenaran data saat ada konkurensi. Apa yang terjadi kalau siswa menekan submit tepat di detik waktu ujian habis, atau menekan "Mulai ujian" dua kali? Itu yang saya ceritakan di Part 6.

BagikanLinkedInXWhatsApp

Ditulis oleh Muhammad Fari Madyan

Senior Full Stack Engineer dan co-founder LampungDev. Saya menuliskan apa yang saya bangun supaya orang lain bisa ikut belajar.

Ajak kerja sama
← bagian 4Panduan Deployment Single VPS dengan Docker Compose, Host Nginx Reverse Proxy & SSL Let's Encryptbagian 6 →Integritas Ujian Saat Konkuren

Muhammad Fari Madyan

Senior Full Stack Engineer building web and mobile systems that hold up in production. Co-founder of LampungDev. Based in Bandar Lampung, Indonesia (UTC+7), working remote.

Work

Case studiesCahTixExam platform, 4 stacksOpen source

© 2026 Muhammad Fari Madyan

Designed and built by Muhammad Fari Madyan