Authentication #

// ANTI-PATTERN 1: menyimpan password plaintext
user.Password = "userpassword123" // JANGAN PERNAH

// ANTI-PATTERN 2: enkripsi (bukan hashing)
user.Password = encrypt(password, secretKey)
// Enkripsi bisa di-decrypt. Jika secretKey bocor, semua password bocor.

// ANTI-PATTERN 3: hash tanpa salt — rentan rainbow table attack
user.Password = sha256.Sum256([]byte(password))
// Dua user dengan password sama menghasilkan hash sama
// → attacker bisa precompute rainbow table dan langsung match

// ANTI-PATTERN 4: hash cepat — rentan brute force
// SHA256 bisa menghitung miliaran hash per detik di GPU modern
// Database 1 juta password bisa di-crack dalam jam jika hash bocor

// BENAR: gunakan algoritma yang dirancang untuk password hashing.
// golang.org/x/crypto/argon2 — Argon2id (rekomendasi OWASP 2023).
func hashPassword(password string, salt []byte) string {
    // time = 3 iterasi — lebih tinggi = lebih lambat = lebih aman
    // memory = 65536 KiB (64MB) — mencegah GPU/ASIC attack
    // threads = 2, keyLen = 32 byte output; salt random per password
    hash := argon2.IDKey([]byte(password), salt, 3, 64*1024, 2, 32)
    return fmt.Sprintf("$argon2id$v=19$m=65536,t=3,p=2$%s$%s",
        base64.RawStdEncoding.EncodeToString(salt),
        base64.RawStdEncoding.EncodeToString(hash))
}

func verifyPassword(stored, provided string, salt []byte) bool {
    // Hitung ulang hash dan bandingkan dalam waktu konstan
    expected := argon2.IDKey([]byte(provided), salt, 3, 64*1024, 2, 32)
    return subtle.ConstantTimeCompare([]byte(stored), expected) == 1
}

func needsRehash(stored string) bool {
    // Cek apakah stored hash masih memakai parameter saat ini
    return !strings.HasPrefix(stored, "$argon2id$v=19$m=65536,t=3,p=2$")
}

// Password policy berdasarkan NIST SP 800-63B (lebih baru dan lebih baik)
const (
    minLength    = 12  // panjang minimum, bukan maksimum
    maxLength    = 128 // ada maksimum untuk mencegah DoS via hash computation
    pwnedAPIURL  = "https://api.pwnedpasswords.com/range/"
)

func validatePassword(password string) (bool, []string) {
    var errors []string

    // 1. Panjang minimum
    if len(password) < minLength {
        errors = append(errors, fmt.Sprintf("Password minimal %d karakter", minLength))
    }

    // 2. Panjang maksimum
    if len(password) > maxLength {
        errors = append(errors, fmt.Sprintf("Password maksimal %d karakter", maxLength))
    }

    // 3. Cek terhadap database password yang diketahui bocor (HaveIBeenPwned API)
    if isPasswordPwned(password) {
        errors = append(errors,
            "Password ini ada dalam daftar password yang diketahui bocor. "+
                "Silakan pilih password yang berbeda.")
    }

    // 4. Cek konteks (jangan gunakan nama aplikasi, username, dll)
    // Ini lebih berguna dari requirement "harus ada angka dan huruf besar"

    return len(errors) == 0, errors
}

func isPasswordPwned(password string) bool {
    // Cek HaveIBeenPwned menggunakan k-Anonymity — password tidak pernah dikirim
    sum := sha1.Sum([]byte(password))
    hexStr := strings.ToUpper(hex.EncodeToString(sum[:]))
    prefix, suffix := hexStr[:5], hexStr[5:]

    resp, err := http.Get(pwnedAPIURL + prefix)
    if err != nil {
        return false // Jika API gagal, jangan blokir user
    }
    defer resp.Body.Close()
    if resp.StatusCode != 200 {
        return false
    }

    body, _ := io.ReadAll(resp.Body)
    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 count > 0
        }
    }
    return false
}

// Implementasi TOTP dengan github.com/pquerna/otp
func setupTOTPForUser(userID int, username string) map[string]any {
    // Generate secret key yang aman
    key, err := totp.Generate(totp.GenerateOpts{
        Issuer:      "MyApp",
        AccountName: username,
    })
    if err != nil {
        return nil
    }

    // Simpan secret ke database (terenkripsi!)
    storeMFASecret(userID, encryptSecret(key.Secret()))

    // Generate provisioning URI untuk QR code
    provisioningURI := key.URL()
    // Generate QR code (github.com/skip2/go-qrcode) dari URI dan
    // tampilkan ke user untuk di-scan dengan authenticator app

    // Juga tampilkan secret key sebagai teks (untuk manual entry)
    return map[string]any{
        "secret":           key.Secret(), // tampilkan SEKALI, jangan simpan di plain
        "provisioning_uri": provisioningURI,
        // backup codes untuk recovery
        "backup_codes": generateBackupCodes(userID),
    }
}

func verifyTOTP(userID int, providedCode string) bool {
    secret := decryptSecret(getMFASecret(userID))

    // validWindow=1 mengizinkan 1 interval maju/mundur (30 detik)
    // untuk mengakomodasi sedikit perbedaan waktu antara server dan device
    return totp.Validate(providedCode, secret)
}

func generateBackupCodes(userID int) []string {
    // Generate 10 backup codes; simpan hanya hash-nya
    codes := make([]string, 0, 10)
    for i := 0; i < 10; i++ {
        codes = append(codes, randomHex(4))
    }
    // Simpan hash dari backup codes (bukan plaintext)
    // User hanya bisa melihatnya sekali saat setup
    storeBackupCodesHashed(userID, codes)
    return codes // tampilkan ke user sekali saja
}

// ANTI-PATTERN 1: algoritma "none" — mematikan signature verification
token := jwt.NewWithClaims(jwt.SigningMethodNone, jwt.MapClaims{"user_id": 1})
// Siapapun bisa membuat token tanpa signature

// ANTI-PATTERN 2: kunci HS256 yang lemah
token, _ = jwt.NewWithClaims(jwt.SigningMethodHS256,
    jwt.MapClaims{"user_id": 1}).SignedString([]byte("secret"))
// "secret" bisa di-crack dengan wordlist attack dalam detik

// ANTI-PATTERN 3: expiry yang terlalu panjang
claims := jwt.MapClaims{
    "user_id": 1,
    "exp":     time.Now().Add(365 * 24 * time.Hour).Unix(), // 1 tahun!
}
// Token yang dikompromikan valid selama 1 tahun tanpa cara revoke

// BENAR: konfigurasi JWT yang aman (github.com/golang-jwt/jwt/v5)
// HS256: secret key minimal 256-bit (32 byte)
jwtSecret := os.Getenv("JWT_SECRET") // kunci random 32+ byte
if len(jwtSecret) < 32 {
    panic("JWT secret terlalu pendek")
}

// Atau RS256 untuk arsitektur multi-service
// RS256 memungkinkan service lain verifikasi token tanpa tahu private key

func createAccessToken(userID int, additionalClaims map[string]any) (string, error) {
    now := time.Now()
    claims := jwt.MapClaims{
        "sub":  strconv.Itoa(userID),             // subjek
        "iat":  now.Unix(),                       // diterbitkan pada
        "exp":  now.Add(15 * time.Minute).Unix(), // expiry pendek!
        "jti":  randomToken(16),                  // ID token unik
        "type": "access",                         // bedakan access vs refresh token
    }
    for k, v := range additionalClaims {
        claims[k] = v
    }
    return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString([]byte(jwtSecret))
}

func verifyAccessToken(tokenStr string) (jwt.MapClaims, error) {
    token, err := jwt.Parse(tokenStr, func(t *jwt.Token) (any, error) {
        // eksplisit — jangan terima algoritma "none" atau campuran
        if t.Method != jwt.SigningMethodHS256 {
            return nil, errors.New("metode signing tidak terduga")
        }
        return []byte(jwtSecret), nil
    })
    if err != nil {
        return nil, err
    }
    claims, ok := token.Claims.(jwt.MapClaims)
    if !ok || !token.Valid {
        return nil, errors.New("token tidak valid")
    }
    // wajib ada exp, iat, sub, jti, type
    if claims["type"] != "access" {
        return nil, errors.New("tipe token salah")
    }

    // Opsional: cek token blacklist jika butuh revocation
    if isTokenRevoked(claims["jti"].(string)) {
        return nil, errors.New("token sudah di-revoke")
    }
    return claims, nil
}

// Rate limiter berbasis Redis (github.com/redis/go-redis/v9)
type RateLimiter struct {
    client         *redis.Client
    maxAttempts    int
    windowSeconds  time.Duration
    lockoutSeconds time.Duration
}

func (r *RateLimiter) checkRateLimit(ctx context.Context, identifier string) (bool, int) {
    key := "login_attempts:" + identifier
    lockoutKey := "login_lockout:" + identifier

    // Cek apakah sedang dalam lockout
    lockoutRemaining, _ := r.client.TTL(ctx, lockoutKey).Result()
    if lockoutRemaining > 0 {
        return false, int(lockoutRemaining.Seconds())
    }

    // Cek jumlah percobaan dalam window
    attempts, _ := r.client.Get(ctx, key).Int()
    if attempts >= r.maxAttempts {
        // Set lockout
        r.client.Set(ctx, lockoutKey, 1, r.lockoutSeconds)
        r.client.Del(ctx, key)
        return false, int(r.lockoutSeconds.Seconds())
    }
    return true, 0
}

func (r *RateLimiter) recordAttempt(ctx context.Context, identifier string) {
    // Record satu attempt
    key := "login_attempts:" + identifier
    pipe := r.client.Pipeline()
    pipe.Incr(ctx, key)
    pipe.Expire(ctx, key, r.windowSeconds)
    pipe.Exec(ctx)
}

func (r *RateLimiter) resetAttempts(ctx context.Context, identifier string) {
    // Reset setelah login berhasil
    r.client.Del(ctx, "login_attempts:"+identifier)
    r.client.Del(ctx, "login_lockout:"+identifier)
}

// Limiter per IP: 10 percobaan per 5 menit
ipLimiter := &RateLimiter{client: rdb, maxAttempts: 10,
    windowSeconds: 5 * time.Minute, lockoutSeconds: 5 * time.Minute}

// Limiter per akun: 5 percobaan per 15 menit (lebih ketat)
accountLimiter := &RateLimiter{client: rdb, maxAttempts: 5,
    windowSeconds: 15 * time.Minute, lockoutSeconds: 15 * time.Minute}

// Handler login (net/http)
func loginHandler(w http.ResponseWriter, r *http.Request) {
    email := r.FormValue("email")
    password := r.FormValue("password")
    ip := remoteIP(r)

    // Cek rate limit per IP
    allowed, retryAfter := ipLimiter.checkRateLimit(r.Context(), ip)
    if !allowed {
        w.Header().Set("Retry-After", strconv.Itoa(retryAfter))
        http.Error(w, `{"error": "Terlalu banyak percobaan. Coba lagi dalam beberapa menit."}`, http.StatusTooManyRequests)
        return
    }

    // Cek rate limit per akun
    allowed, retryAfter = accountLimiter.checkRateLimit(r.Context(), email)
    if !allowed {
        w.Header().Set("Retry-After", strconv.Itoa(retryAfter))
        http.Error(w, `{"error": "Akun sementara terkunci karena terlalu banyak percobaan."}`, http.StatusTooManyRequests)
        return
    }

    // Record attempt SEBELUM verifikasi (mencegah timing attack)
    ipLimiter.recordAttempt(r.Context(), ip)
    accountLimiter.recordAttempt(r.Context(), email)

    user := findUserByEmail(email)

    // PENTING: selalu verifikasi password (timing-safe)
    // Jika user tidak ada, tetap jalankan verify untuk waktu yang konsisten
    if user == nil {
        verifyPassword(dummyHash, password) // timing dummy
        http.Error(w, `{"error": "Email atau password tidak valid"}`, http.StatusUnauthorized)
        return
    }

    if !verifyPassword(user.PasswordHash, password) {
        http.Error(w, `{"error": "Email atau password tidak valid"}`, http.StatusUnauthorized)
        return
    }

    // Login berhasil — reset rate limit
    ipLimiter.resetAttempts(r.Context(), ip)
    accountLimiter.resetAttempts(r.Context(), email)

    // Cek apakah hash perlu di-upgrade
    if needsRehash(user.PasswordHash) {
        user.PasswordHash = hashPassword(password, newSalt())
    }

    sessionToken := createSession(user.ID, r)
    setAuthCookie(w, sessionToken)
    w.WriteHeader(http.StatusOK)
}

// Flow reset password
var resetTokenExpiry = 15 * time.Minute

func requestPasswordReset(email string) {
    user := findUserByEmail(email)

    // PENTING: response SELALU sama terlepas apakah email ada atau tidak
    // Mencegah user enumeration (mengetahui apakah email terdaftar)

    if user != nil {
        // Generate token yang kuat
        rawToken := randomToken(32)

        // Simpan HASH dari token (bukan token itu sendiri)
        // Jika database bocor, token tidak langsung bisa dipakai
        tokenHash := sha256Hex(rawToken)

        // Invalidasi semua token reset sebelumnya
        deleteResetTokensForUser(user.ID)

        createResetToken(ResetTokenRecord{
            UserID:    user.ID,
            TokenHash: tokenHash,
            ExpiresAt: time.Now().Add(resetTokenExpiry),
            Used:      false,
        })

        // rawToken dikirim ke email, bukan tokenHash
        sendResetEmail(user.Email,
            "https://app.com/reset-password?token="+rawToken)
    }

    // Response selalu sama — jangan bedakan "email ada" vs "tidak ada"
    _ = jsonResponse(map[string]string{
        "message": "Jika email terdaftar, instruksi reset akan dikirimkan.",
    })
}

func resetPassword(rawToken, newPassword string) error {
    tokenHash := sha256Hex(rawToken)

    record := findResetToken(tokenHash, false)
    if record == nil {
        return errors.New("token tidak valid atau sudah digunakan")
    }
    if record.ExpiresAt.Before(time.Now()) {
        return errors.New("token sudah kedaluwarsa")
    }

    // Validasi password baru
    isValid, errorsList := validatePassword(newPassword)
    if !isValid {
        return errors.New(strings.Join(errorsList, "; "))
    }

    // Update password
    user := findUserByID(record.UserID)
    user.PasswordHash = hashPassword(newPassword)

    // Tandai token sebagai sudah digunakan (single-use)
    record.Used = true
    record.UsedAt = time.Now()

    // PENTING: invalidasi semua session aktif setelah reset
    // Jika account dikompromikan dan attacker yang set password,
    // session attacker juga harus diinvalidasi
    invalidateAllSessions(user.ID)

    saveResetToken(record)

    // Kirim notifikasi email bahwa password berhasil diubah
    sendPasswordChangedNotification(user.Email)
    return nil
}