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:
- Pull Request #5: fix/cors-allowed-origins-production: origin CORS yang bisa diatur untuk produksi.
- Pull Request #6: fix/security-hardening: 57 file, +1.510 / −446 baris. Isinya rotasi refresh token di sisi server, wajib ganti password, otorisasi file, otorisasi channel STOMP, dan cara membaca IP klien yang benar.
Di artikel ini saya ajak kamu menelusuri temuan itu satu per satu: bagaimana celahnya bisa disalahgunakan, lalu kode yang saya pakai untuk menutupnya.
Klik diagram untuk membukanya dalam ukuran penuh.
1. Ringkasan Temuan
| # | Temuan | Dampak | Diperbaiki di |
|---|---|---|---|
| 1 | CORS memblokir origin produksi; perbaikan pertama fallback ke * dengan credentials | Produksi rusak, lalu fallback terlalu longgar | PR #5, PR #6 |
| 2 | IP klien dibaca dari CF-Connecting-IP / X-Forwarded-For | Rate limit tembus dengan satu header | PR #6 |
| 3 | Bucket rate limit disimpan di ConcurrentHashMap tanpa batas | Heap habis dengan merotasi IP atau email | PR #6 |
| 4 | Login sukses me-reset bucket IP | Penyerang me-reset limitnya sendiri dengan login | PR #6 |
| 5 | Refresh token stateless, dan diterima sebagai access token | Logout tidak nyata; token curian bisa dipakai 7 hari | PR #6 |
| 6 | JWT_SECRET default ter-commit di application.yml | Siapa pun bisa memalsukan token di deploy yang salah konfigurasi | PR #6 |
| 7 | Akun seed memakai password yang terdokumentasi | Pengambilalihan akun di instance yang masih memakai seed | PR #6 |
| 8 | /api/v1/files/** berstatus permitAll() | Siapa pun yang punya URL bisa mengunduh tugas siswa | PR #6 |
| 9 | STOMP: guru mana pun bisa memantau ujian mana pun, wildcard diizinkan, klien bisa SEND ke /topic | Kebocoran data dan event proctoring palsu | PR #6 |
| 10 | Swagger aktif, log DEBUG, password DB kosong diizinkan di produksi | Kebocoran informasi, default yang lemah | PR #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:
// 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.
// 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:
// 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:
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:
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:
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:
# /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:
// 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:
/**
* 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:
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:
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:
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):
@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:
// 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/logoutmencabutjti. - Ganti password me-logout semua perangkat.
changePasswordmemanggilrevokeAll(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:
-- 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:
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,
ProtectedRoutemengarahkan user denganmustChangePasswordke 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:
.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:
/**
* - 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:
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:
// 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:
- Guru mana pun bisa memantau ujian mana pun, termasuk kelas sekolah lain di instance yang sama. Aturannya memeriksa role, bukan kepemilikan.
- 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. - Klien bisa
SENDlangsung ke/topic/..., lalu menyuntikkan eventEXAM_SUBMITTEDatauVIOLATION_REPORTEDpalsu ke monitor guru.
Interceptor yang baru menangani setiap perintah secara eksplisit dan menolak apa pun yang tidak dikenal:
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);
}
| Destination | Siapa yang boleh subscribe atau send |
|---|---|
/topic/exams/{id}/monitor | Subscribe: 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 itu | Tidak 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:
| Area | Perubahan |
|---|---|
| Dokumentasi API | SPRINGDOC_ENABLED=false sebagai default di docker-compose.prod.yml |
| Logging | com.elearning di ${LOG_LEVEL_APP:INFO}, bukan DEBUG |
| Nginx (container SPA) | server_tokens off, Permissions-Policy: camera=(), microphone=(), geolocation=(), payment=() |
| Header lawas | X-XSS-Protection: 0: XSS auditor lama sudah dihapus dari browser modern dan bisa disalahgunakan untuk kebocoran lintas situs |
| Runtime | Spring Boot 3.5.7, Node 22 untuk build frontend |
| Supply chain | Dependabot untuk Maven, npm, image Docker, dan GitHub Actions |
| Deploy | deploy.sh: git pull, build semua service atau satu (./deploy.sh backend --no-cache), up -d, hapus image lama |
11. Sebelum dan Sesudah
| Area | Setelah Part 3 | Setelah PR #6 |
|---|---|---|
| IP klien | Nilai pertama dari header yang dikendalikan klien | RemoteIpValve, hanya proxy tepercaya |
| Memori rate limit | Map tanpa batas | Caffeine, maks 100 ribu key, kedaluwarsa 10 menit |
| Refresh token | Stateless, berlaku 7 hari, bisa jadi access token | jti sekali pakai di Redis, claim typ diperiksa |
| Logout | Hanya di sisi klien | Dicabut di server; cabut semua saat ganti password |
| JWT secret | Nilai default di application.yml | Wajib diisi; nilai publik ditolak |
| Password seed | Bisa dipakai selamanya | Wajib diganti saat login pertama (kecuali demo) |
| Download file | URL publik | Otorisasi per objek, 404 saat ditolak |
| STOMP | Cek role di satu pola | Deny 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.
- Demo live: https://spring-elearning.mfarim.com
- Source code: github.com/mfarim/spring-elearning-react
- Pull request: #5, #6

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.

