Brute Force #

// Rate limiter berlapis untuk endpoint login:
// 1. Per IP — melindungi dari satu IP yang agresif
// 2. Per akun — melindungi dari credential stuffing dari banyak IP
// 3. Per IP + akun — kombinasi yang paling presisi

// Konfigurasi: (maxAttempts, windowSeconds, lockoutSeconds)
var (
	ipLimit      = [3]int{30, 300, 300}    // 30 per 5 menit, lockout 5 menit
	accountLimit = [3]int{5, 900, 900}     // 5 per 15 menit, lockout 15 menit
	globalLimit  = [3]int{10000, 60, -1}   // Global: 10k per menit (DDoS guard)
)

type RateLimitResult struct {
	Allowed           bool
	RemainingAttempts int
	ResetAfterSeconds int
	LockoutSeconds    int // -1 jika tidak ada lockout
}

type LoginRateLimiter struct{}

// CheckAll mengecek semua rate limit dan mencatat attempt.
// Return hasil dengan Allowed=false jika salah satu limit terlampaui.
func (l LoginRateLimiter) CheckAll(ip, email string) RateLimitResult {
	// Cek lockout aktif
	if result, locked := l.checkLockout(ip, email); locked {
		return result
	}

	// Cek rate limit per IP
	ipResult := l.checkLimit("rl:ip:"+ip, ipLimit)
	if !ipResult.Allowed {
		l.setLockout("lockout:ip:"+ip, ipLimit[2])
		return ipResult
	}

	// Cek rate limit per akun (email di-hash untuk privacy)
	emailHash := hashEmail(email)
	accountResult := l.checkLimit("rl:account:"+emailHash, accountLimit)
	if !accountResult.Allowed {
		l.setLockout("lockout:account:"+emailHash, accountLimit[2])
		return accountResult
	}

	remaining := ipResult.RemainingAttempts
	if accountResult.RemainingAttempts < remaining {
		remaining = accountResult.RemainingAttempts
	}
	reset := ipResult.ResetAfterSeconds
	if accountResult.ResetAfterSeconds < reset {
		reset = accountResult.ResetAfterSeconds
	}
	return RateLimitResult{Allowed: true, RemainingAttempts: remaining, ResetAfterSeconds: reset}
}

func (l LoginRateLimiter) checkLimit(key string, limit [3]int) RateLimitResult {
	now := time.Now().Unix()
	// Redis sorted set: hapus entri lama, hitung, tambah, set TTL
	redis.ZRemRangeByScore(key, "0", strconv.FormatInt(now-int64(limit[1]), 10))
	count := redis.ZCard(key)
	redis.ZAdd(key, redis.Z{Score: float64(now), Member: strconv.FormatInt(now, 10)})
	redis.Expire(key, time.Duration(limit[1])*time.Second)

	remaining := limit[0] - int(count) - 1
	if remaining < 0 {
		remaining = 0
	}
	return RateLimitResult{
		Allowed:           count < int64(limit[0]),
		RemainingAttempts: remaining,
		ResetAfterSeconds: limit[1],
	}
}

func (l LoginRateLimiter) checkLockout(ip, email string) (RateLimitResult, bool) {
	for _, key := range []string{"lockout:ip:" + ip, "lockout:account:" + hashEmail(email)} {
		if ttl := redis.TTL(key).Seconds(); ttl > 0 {
			return RateLimitResult{
				Allowed:           false,
				RemainingAttempts: 0,
				ResetAfterSeconds: int(ttl),
				LockoutSeconds:    int(ttl),
			}, true
		}
	}
	return RateLimitResult{}, false
}

func (l LoginRateLimiter) setLockout(key string, seconds int) {
	redis.SetEX(key, time.Duration(seconds)*time.Second, 1)
}

// ResetOnSuccess membersihkan counter setelah login berhasil.
func (l LoginRateLimiter) ResetOnSuccess(ip, email string) {
	redis.Del("rl:ip:"+ip, "rl:account:"+hashEmail(email),
		"lockout:ip:"+ip, "lockout:account:"+hashEmail(email))
}

func hashEmail(email string) string {
	sum := sha256.Sum256([]byte(strings.ToLower(email)))
	return hex.EncodeToString(sum[:])[:16]
}

func main() {
	var loginLimiter LoginRateLimiter

	// Registrasi router (pseudo-code, meniru route Flask)
	app.Post("/login", func(req Request, res Response) {
		ip := getRealIP(req) // handle proxy headers dengan hati-hati
		email := strings.ToLower(strings.TrimSpace(req.JSON("email")))

		// Cek rate limit sebelum apapun
		result := loginLimiter.CheckAll(ip, email)
		if !result.Allowed {
			retryAfter := result.ResetAfterSeconds
			if result.LockoutSeconds > 0 {
				retryAfter = result.LockoutSeconds
			}
			res.Status(429)
			res.Header("Retry-After", strconv.Itoa(retryAfter))
			res.JSON(map[string]any{"error": "Too many attempts", "retry_after": retryAfter})
			return
		}

		// Proses login dengan timing yang konsisten
		user := authenticateUser(email, req.JSON("password"))
		if user != nil {
			loginLimiter.ResetOnSuccess(ip, email)
			setAuthCookie(res, createSession(user.ID, req))
			res.JSON(map[string]any{"status": "ok"})
			return
		}

		// Login gagal — pesan yang sama untuk semua kasus
		res.Status(401)
		res.JSON(map[string]any{"error": "Email atau password tidak valid"})
	})
}

// ANTI-PATTERN: timing leak — attacker bisa bedakan "email tidak ada" vs "password salah"
func main() {
	app.Post("/login", func(req Request, res Response) {
		email := req.JSON("email")
		password := req.JSON("password")

		user := findUserByEmail(email)

		if user == nil {
			// Return CEPAT — tidak ada hash computation
			res.Status(401)
			res.JSON(map[string]any{"error": "Invalid credentials"})
			return
		}

		if !verifyPassword(password, user.PasswordHash) {
			// Return LAMBAT — hash computation terjadi
			res.Status(401)
			res.JSON(map[string]any{"error": "Invalid credentials"})
			return
		}
	})
}

// Attacker mengukur response time:
// < 5ms = email tidak ada di database (langsung return)
// > 100ms = email ada tapi password salah (hash computation terjadi)
// → Attacker bisa enumerate email valid tanpa trigger rate limit

// BENAR: waktu respons yang konsisten
var ph = PasswordHasher{}

// Hash dummy yang valid untuk digunakan ketika user tidak ditemukan
var dummyHash = ph.Hash("dummy_password_that_never_matches")

func init() {
	app.Post("/login", func(req Request, res Response) {
		email := req.JSON("email")
		password := req.JSON("password")

		user := findUserByEmail(email)
		passwordHash := dummyHash
		if user != nil {
			passwordHash = user.PasswordHash
		}

		// Verifikasi selalu dijalankan, terlepas apakah user ada atau tidak
		isValid, err := ph.Verify(passwordHash, password)
		if err == nil && user != nil && isValid {
			// Login berhasil
			res.JSON(successResponse(user))
			return
		}

		// Login gagal — pesan yang sama
		res.Status(401)
		res.JSON(map[string]any{"error": "Email atau password tidak valid"})
	})
}

// Lockout yang cerdas:
// - Tidak langsung lockout permanen
// - Progressive delay
// - Tidak memungkinkan attacker untuk DOS akun user lain

type SmartAccountLockout struct {
	// Progressive lockout: semakin banyak gagal, semakin lama locked
	lockoutSchedule [][2]int
}

func NewSmartAccountLockout() *SmartAccountLockout {
	return &SmartAccountLockout{
		lockoutSchedule: [][2]int{
			{3, 30},     // Setelah 3 gagal: lock 30 detik
			{5, 300},    // Setelah 5 gagal: lock 5 menit
			{10, 1800},  // Setelah 10 gagal: lock 30 menit
			{20, 86400}, // Setelah 20 gagal: lock 24 jam
		},
	}
}

// GetLockoutDuration mengembalikan durasi lockout berdasarkan jumlah kegagalan.
func (s *SmartAccountLockout) GetLockoutDuration(failureCount int) int {
	duration := 0
	for _, entry := range s.lockoutSchedule {
		if failureCount >= entry[0] {
			duration = entry[1]
		}
	}
	return duration
}

func (s *SmartAccountLockout) RecordFailure(accountKey string) map[string]any {
	key := "login_failures:" + accountKey

	// Increment failure count
	failureCount := redis.Incr(key)

	// Set expiry jika baru dibuat
	if failureCount == 1 {
		redis.Expire(key, 24*time.Hour) // reset setelah 24 jam tanpa activity
	}

	// Tentukan lockout duration
	lockoutDuration := s.GetLockoutDuration(failureCount)
	if lockoutDuration > 0 {
		redis.SetEX("lockout:"+accountKey, time.Duration(lockoutDuration)*time.Second, failureCount)
	}

	return map[string]any{
		"failure_count":   failureCount,
		"locked":          lockoutDuration > 0,
		"lockout_seconds": lockoutDuration,
	}
}

// IsLocked mengembalikan (is_locked, seconds_remaining).
func (s *SmartAccountLockout) IsLocked(accountKey string) (bool, int) {
	ttl := int(redis.TTL("lockout:" + accountKey).Seconds())
	if ttl < 0 {
		ttl = 0
	}
	return ttl > 0, ttl
}

// UnlockOnSuccess reset setelah login berhasil.
func (s *SmartAccountLockout) UnlockOnSuccess(accountKey string) {
	redis.Del("login_failures:"+accountKey, "lockout:"+accountKey)
}

// Integrasi Google reCAPTCHA v3 (invisible, berbasis score)
var (
func main() {
		recaptchaSecret    = os.Getenv("RECAPTCHA_SECRET_KEY")
}
func init() {
		recaptchaVerifyURL = "https://www.google.com/recaptcha/api/siteverify"
}
func init() {
		recaptchaThreshold = 0.5 // Score 0 (bot) sampai 1 (manusia)
}
)

// VerifyRecaptcha memverifikasi reCAPTCHA token.
// Returns: (is_human, score)
func VerifyRecaptcha(token, action string) (bool, float64) {
	resp, err := http.PostForm(recaptchaVerifyURL, url.Values{
		"secret":   []string{recaptchaSecret},
		"response": []string{token},
	})
	if err != nil {
		// Jika CAPTCHA service down, jangan blokir user legitimate
		// Tapi log untuk monitoring
func init() {
			logger.Warning("reCAPTCHA verification failed — service unavailable")
}
		return true, 1.0 // Default allow jika service down
	}
	defer resp.Body.Close()

	var result struct {
		Success bool    `json:"success"`
		Action  string  `json:"action"`
		Score   float64 `json:"score"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return false, 0.0
	}

	if !result.Success {
		return false, 0.0
	}

	// Verifikasi action sesuai
	if result.Action != action {
		return false, 0.0
	}

	return result.Score >= recaptchaThreshold, result.Score
}

// Registrasi router (pseudo-code, meniru route Flask)
func init() {
	app.Post("/login", func(req Request, res Response) {
		// Ambil CAPTCHA token dari request
		captchaToken := req.JSON("captcha_token")
		if captchaToken == "" {
			res.Status(400)
			res.JSON(map[string]any{"error": "CAPTCHA required"})
			return
		}

		isHuman, score := VerifyRecaptcha(captchaToken, "login")
		if !isHuman {
			logger.Warning("Low reCAPTCHA score on login",
				"score", score, "ip", req.RemoteAddr)
			res.Status(429)
			res.JSON(map[string]any{"error": "CAPTCHA verification failed"})
			return
		}

		// Lanjutkan proses login
		// ...
	})
}

// GeoIP database untuk deteksi lokasi
var reader = geoip2.Open("/path/to/GeoLite2-City.mmdb")

type CredentialStuffingDetector struct {
	Window int
}

// NewCredentialStuffingDetector membuat detector dengan window tertentu.
func NewCredentialStuffingDetector(windowSeconds int) *CredentialStuffingDetector {
	return &CredentialStuffingDetector{Window: windowSeconds}
}

// AnalyzeLoginPattern menganalisis apakah request ini terlihat seperti credential stuffing.
func (d *CredentialStuffingDetector) AnalyzeLoginPattern(ip, email string) map[string]any {
	signals := []string{}

	// Signal 1: User-Agent yang tidak umum atau sama persis antar request
	userAgent := req.UserAgent()
	if d.isSuspiciousUserAgent(userAgent) {
		signals = append(signals, "suspicious_user_agent")
	}

	// Signal 2: Tidak ada header yang biasanya ada di browser nyata
	expectedHeaders := []string{"accept", "accept-language", "accept-encoding"}
	missing := 0
	for _, h := range expectedHeaders {
		if req.Header(h) == "" {
			missing++
		}
	}
	if missing > 1 {
		signals = append(signals, "missing_browser_headers")
	}

	// Signal 3: Login dari banyak email berbeda dari satu IP dalam waktu singkat
	ipKey := "logins_from_ip:" + ip
	emailsFromIP := redis.PFCount(ipKey) // HyperLogLog untuk counting
	if emailsFromIP > 10 {
		signals = append(signals, "many_accounts_from_ip")
	}

	// Signal 4: Lokasi yang tidak konsisten dengan pola login historis
	country, err := reader.Country(ip)
	if err == nil && d.isImpossibleLocation(email, country) {
		signals = append(signals, "impossible_location")
	}

	// Signal 5: IP address dari daftar proxy/VPN/Tor yang diketahui
	if d.isKnownProxyIP(ip) {
		signals = append(signals, "proxy_ip")
	}

	// Record email ini dari IP (dengan TTL)
	redis.PFAdd(ipKey, email)
	redis.Expire(ipKey, time.Duration(d.Window)*time.Second)

	riskScore := len(signals)
	return map[string]any{
		"risk_score": riskScore,
		"signals":    signals,
		"action":     d.determineAction(riskScore),
	}
}

func (d *CredentialStuffingDetector) isSuspiciousUserAgent(ua string) bool {
	// Tool credential stuffing sering menggunakan UA yang aneh
	suspiciousPatterns := []string{
		"python-requests", "axios/", "okhttp/", "curl/",
		"go-http-client", "java/", "php/",
	}
	uaLower := strings.ToLower(ua)
	for _, p := range suspiciousPatterns {
		if strings.Contains(uaLower, p) {
			return true
		}
	}
	return false
}

func (d *CredentialStuffingDetector) determineAction(riskScore int) string {
	switch {
	case riskScore == 0:
		return "allow"
	case riskScore == 1:
		return "monitor" // log tapi izinkan
	case riskScore == 2:
		return "challenge" // tampilkan CAPTCHA
	default:
		return "block" // blokir sementara
	}
}

func (d *CredentialStuffingDetector) isKnownProxyIP(ip string) bool {
	// Cek terhadap database IP proxy/VPN/Tor yang diketahui
	// Bisa menggunakan layanan seperti IPQualityScore, MaxMind, dll
	proxyKey := "known_proxy:" + ip
	return redis.Exists(proxyKey) == 1
}

func (d *CredentialStuffingDetector) isImpossibleLocation(email, currentCountry string) bool {
	// Bandingkan dengan country terakhir yang diketahui
	historyKey := "login_country:" + hashEmail(email)
	lastCountry := redis.Get(historyKey)
	return lastCountry != "" && lastCountry != currentCountry
}

// Registrasi router (pseudo-code, meniru route Flask)
func main() {
	detector := NewCredentialStuffingDetector(300)

	app.Post("/login", func(req Request, res Response) {
		ip := req.RemoteAddr
		email := req.JSON("email")

		// Analisis credential stuffing signals
		analysis := detector.AnalyzeLoginPattern(ip, email)

		if analysis["action"] == "block" {
			res.Status(429)
			res.JSON(map[string]any{"error": "Aktivitas mencurigakan terdeteksi", "retry_after": 300})
			return
		}

		if analysis["action"] == "challenge" {
			// Minta CAPTCHA untuk request mencurigakan
			res.Status(202)
			res.JSON(map[string]any{"challenge_required": true, "challenge_type": "captcha"})
			return
		}

		// Lanjutkan proses login normal
		// ...
	})
}

const hibpAPIURL = "https://api.pwnedpasswords.com/range/{}"

// CheckPasswordBreached mengecek apakah password ada dalam database HaveIBeenPwned.
// Menggunakan k-Anonymity — password tidak dikirim ke API.
// Returns: (is_breached, breach_count)
func CheckPasswordBreached(password string) (bool, int) {
	sum := sha1.Sum([]byte(password))
	sha1Hex := strings.ToUpper(hex.EncodeToString(sum[:]))
	prefix, suffix := sha1Hex[:5], sha1Hex[5:]

	resp, err := http.Get(fmt.Sprintf(hibpAPIURL, prefix))
	if err != nil {
		// Jika API tidak tersedia, jangan blokir — log dan lanjutkan
		logger.Warning("HIBP API unavailable")
		return false, 0
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return false, 0
	}

	for _, line := range strings.Split(string(body), "\n") {
		parts := strings.Split(line, ":")
		if len(parts) == 2 && parts[0] == suffix {
			count, _ := strconv.Atoi(parts[1])
			return true, count
		}
	}
	return false, 0
}

// Gunakan saat registrasi dan saat ganti password
func ValidatePasswordStrength(password string) []string {
	var errors []string

	if len(password) < 12 {
		errors = append(errors, "Password minimal 12 karakter")
	}

	isBreached, count := CheckPasswordBreached(password)
	if isBreached {
		errors = append(errors,
			fmt.Sprintf("Password ini ditemukan dalam %d data breach. Gunakan password yang unik dan belum pernah digunakan.", count))
	}

	return errors
}

// Alert metric yang harus dipantau

// 1. Login failure rate — naik signifikan = tanda serangan
// Baseline: X failure per menit di jam normal
// Alert: jika melebihi 5x baseline selama 5 menit berturut

// 2. Unique email count dari satu IP dalam 5 menit
// Baseline: 1-2 email per IP
// Alert: > 10 email berbeda dari satu IP

// 3. Login success rate — turun signifikan = tanda serangan
// Baseline: 70-80% request login berhasil
// Alert: jika success rate turun di bawah 30% selama 10 menit

// 4. Akun yang sukses login dari lokasi baru
// Alert: user yang biasanya login dari Jakarta
//        tiba-tiba login dari IP di Eropa Timur

// Implementasi sederhana dengan counter di Redis
func RecordLoginMetric(success bool, ip, email string) {
	now := time.Now().Unix()
	minuteBucket := now - (now % 60)

	pipe := redis.Pipeline()
	if success {
		pipe.Incr(fmt.Sprintf("login:success:%d", minuteBucket))
	} else {
		pipe.Incr(fmt.Sprintf("login:failure:%d", minuteBucket))
		// Track unique emails per IP
		pipe.SAdd(fmt.Sprintf("login:ips:%s:%d", ip, minuteBucket), email)
		pipe.Expire(fmt.Sprintf("login:ips:%s:%d", ip, minuteBucket), 600*time.Second)
	}

	pipe.Expire(fmt.Sprintf("login:success:%d", minuteBucket), 600*time.Second)
	pipe.Expire(fmt.Sprintf("login:failure:%d", minuteBucket), 600*time.Second)
	pipe.Execute()
}

func CheckBruteForceAlert() []string {
	now := time.Now().Unix()
	var alerts []string

	// Cek 5 menit terakhir
	totalSuccess, totalFailure := 0, 0
	for i := 0; i < 5; i++ {
		bucket := now - (now % 60) - int64(i*60)
		success := redis.GetInt(fmt.Sprintf("login:success:%d", bucket))
		failure := redis.GetInt(fmt.Sprintf("login:failure:%d", bucket))
		totalSuccess += success
		totalFailure += failure
	}

	total := totalSuccess + totalFailure
	if total > 0 {
		failureRate := float64(totalFailure) / float64(total)
		if failureRate > 0.7 && total > 100 {
			alerts = append(alerts, fmt.Sprintf(
				"High login failure rate: %.1f%% (%d/%d failed in last 5 min)",
				failureRate*100, totalFailure, total))
		}
	}

	return alerts
}

// ✗ Anti-pattern 1: tidak ada rate limiting pada login endpoint
func loginNoRateLimit(req Request, res Response) {
	user := authenticate(req.JSON("email"), req.JSON("password"))
	_ = user
	// Tidak ada rate limit — bisa coba jutaan password per detik
}

// ✗ Anti-pattern 2: pesan error yang membedakan kasus
func leakyLogin(req Request, res Response) {
	if !userExists {
		res.Status(401)
		res.Write("Email tidak terdaftar") // bocor: email tidak ada
	}
	if wrongPassword {
		res.Status(401)
		res.Write("Password salah") // bocor: email valid
	}
	// ✓ Solusi: "Email atau password tidak valid" untuk semua kasus
}

// ✗ Anti-pattern 3: lockout yang bisa di-abuse untuk DOS akun orang lain
// Attacker sengaja mencoba 10x dengan email target
// → Akun target terkunci
// ✓ Solusi: progressive delay + notifikasi email, bukan hard lockout permanen

// ✗ Anti-pattern 4: rate limit hanya per IP
// Attacker menggunakan ribuan IP berbeda (botnet, residential proxy)
// → Setiap IP hanya 1-2 attempt → tidak pernah trigger IP limit
// ✓ Solusi: rate limit per akun JUGA, bukan hanya per IP

// ✗ Anti-pattern 5: tidak ada monitoring
// Credential stuffing berjalan berhari-hari tanpa terdeteksi
// ✓ Solusi: alert untuk anomali login failure rate

// ✗ Anti-pattern 6: reset rate limit setelah successful login dari IP yang sama
// Attacker berhasil login ke satu akun → rate limit direset untuk IP itu
// → Bisa lanjut coba akun lain dari IP yang sama tanpa limit
// ✓ Solusi: reset hanya untuk akun yang berhasil, bukan untuk IP