Chương 01: Authentication (Xác thực danh tính)

// CHUẨN AN TOÀN JAVA: Dùng thư viện Passay kiểm tra Entropy & Danh sách đen
import org.passay.*;

@PostMapping("/register")
public ResponseEntity register(@Valid @RequestBody UserRegistrationRequest request) {
    PasswordValidator validator = new PasswordValidator(Arrays.asList(
        new LengthRule(12, 128),
        new CharacterRule(EnglishCharacterData.UpperCase, 1),
        new CharacterRule(EnglishCharacterData.LowerCase, 1),
        new CharacterRule(EnglishCharacterData.Digit, 1),
        new CharacterRule(EnglishCharacterData.Special, 1),
        new WhitespaceRule()
    ));

    RuleResult result = validator.validate(new PasswordData(request.getPassword()));
    if (!result.isValid()) {
        return ResponseEntity.badRequest().body(validator.getMessages(result));
    }
    userService.createSecureUser(request);
    return ResponseEntity.ok(Map.of("message", "Đăng ký thành công"));
}

// CHUẨN AN TOÀN SPRING SECURITY: Sử dụng Argon2PasswordEncoder
import org.springframework.security.crypto.argon2.Argon2PasswordEncoder;

@Bean
public PasswordEncoder passwordEncoder() {
    return Argon2PasswordEncoder.defaultsForSpringSecurity_v5_8();
}

// Lưu mật khẩu:
String hash = passwordEncoder.encode(rawPassword);
// Xác thực đăng nhập:
boolean ok = passwordEncoder.matches(rawPassword, storedHash);

// CHUẨN MFA SPRING BOOT: Xác thực TOTP qua thư viện aerogear-otp-java
import org.jboss.aerogear.security.otp.Totp;

@PostMapping("/verify-totp")
public ResponseEntity verifyTotp(@RequestBody TotpVerificationRequest req) {
    User user = userService.findTempAuthenticatedUser(req.tempToken());
    Totp totp = new Totp(user.getMfaSecret());
    
    // Kiểm tra mã 6 số trong cửa sổ thời gian (RFC 6238)
    if (!totp.verify(req.code())) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Mã TOTP không đúng");
    }
    
    String accessToken = jwtService.generateAccessToken(user);
    return ResponseEntity.ok(new AuthResponse(accessToken));
}

// CHUẨN BẢO MẬT SPRING SECURITY 6: Đổi Session ID + Cookie an toàn
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
        .sessionManagement(session -> session
            .sessionFixation().migrateSession() // Tự động đổi Session ID mới khi login
            .maximumSessions(1) // Giới hạn 1 phiên đồng thời
        );
    return http.build();
}
// application.properties:
// server.servlet.session.cookie.http-only=true
// server.servlet.session.cookie.secure=true
// server.servlet.session.cookie.same-site=strict

// CHUẨN: Lấy token từ Header Authorization Bearer bằng Spring Security Filter
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        String authHeader = request.getHeader(HttpHeaders.AUTHORIZATION);
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String jwt = authHeader.substring(7);
            // Xác thực token và nạp vào SecurityContextHolder
            jwtService.authenticate(jwt, request);
        }
        filterChain.doFilter(request, response);
    }
}

// CHUẨN AN TOÀN JAVA: Dùng JJWT verifyWith(signingKey)
import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;

public Jws validateAndParseJwt(String token, SecretKey signingKey) {
    return Jwts.parser()
        .verifyWith(signingKey) // Bắt buộc kiểm tra chữ ký với khóa mật mã
        .requireIssuer("https://auth.mycompany.com")
        .requireAudience("https://api.mycompany.com")
        .build()
        .parseSignedClaims(token); // Tự động ném JwtException nếu sai chữ ký hoặc hết hạn!
}

// CHUẨN AN TOÀN: Access Token chỉ sống tối đa 15 phút
String accessToken = Jwts.builder()
    .subject(user.getId().toString())
    .claim("scope", "read:profile")
    .issuedAt(new Date())
    .expiration(new Date(System.currentTimeMillis() + 15 * 60 * 1000)) // 15 phút
    .signWith(key, Jwts.SIG.HS256)
    .compact();

// CHUẨN REFRESH TOKEN ROTATION & REUSE DETECTION TRONG SPRING BOOT:
@Transactional
@PostMapping("/refresh")
public ResponseEntity refreshToken(@CookieValue("refreshToken") String tokenStr) {
    RefreshToken token = tokenRepo.findByToken(tokenStr)
        .orElseThrow(() -> new TokenRefreshException("Token không tồn tại"));

    // Phát hiện gian lận: Token đã bị thu hồi mà lại đem ra dùng lại!
    if (token.isRevoked()) {
        tokenRepo.revokeAllTokensForUser(token.getUser().getId()); // HỦY TOÀN BỘ PHIÊN!
        throw new SecurityException("Phát hiện xâm nhập trái phép! Vui lòng đăng nhập lại.");
    }

    // Thu hồi token hiện tại
    token.setRevoked(true);
    tokenRepo.save(token);

    // Cấp phát token mới hoàn toàn
    RefreshToken newRefreshToken = tokenService.createRefreshToken(token.getUser());
    String newAccessToken = jwtService.createAccessToken(token.getUser());

    ResponseCookie cookie = ResponseCookie.from("refreshToken", newRefreshToken.getToken())
        .httpOnly(true).secure(true).path("/api/auth").sameSite("Strict").build();

    return ResponseEntity.ok().header(HttpHeaders.SET_COOKIE, cookie.toString())
        .body(new TokenResponse(newAccessToken));
}

// CHUẨN AN TOÀN SPRING BOOT: Dùng LoginAttemptService với Guava Cache / Redis
@Service
public class LoginAttemptService {
    private final int MAX_ATTEMPT = 5;
    private LoadingCache attemptsCache = CacheBuilder.newBuilder()
        .expireAfterWrite(15, TimeUnit.MINUTES)
        .build(new CacheLoader<>() { public Integer load(String key) { return 0; } });

    public void loginFailed(String key) {
        int attempts = attemptsCache.getUnchecked(key);
        attemptsCache.put(key, attempts + 1);
    }

    public boolean isBlocked(String key) {
        return attemptsCache.getUnchecked(key) >= MAX_ATTEMPT;
    }

    public void loginSucceeded(String key) {
        attemptsCache.invalidate(key);
    }
}

// CHUẨN AN TOÀN JAVA: Dùng SecureRandom + Băm token trước khi lưu vào CSDL
import java.security.SecureRandom;

public void createPasswordResetToken(String email) {
    User user = userRepo.findByEmail(email).orElse(null);
    if (user != null) {
        byte[] randomBytes = new byte[32];
        new SecureRandom().nextBytes(randomBytes);
        String rawToken = HexFormat.of().formatHex(randomBytes);

        // Chỉ lưu bản băm SHA-256 của token vào database
        String tokenHash = Hashing.sha256().hashString(rawToken, StandardCharsets.UTF_8).toString();
        user.setResetTokenHash(tokenHash);
        user.setResetTokenExpiry(Instant.now().plus(15, ChronoUnit.MINUTES));
        userRepo.save(user);

        emailService.sendResetEmail(user.getEmail(), rawToken);
    }
    // Luôn trả về phản hồi chung để chống User Enumeration!
}

// CHUẨN AN TOÀN SPRING BOOT: Dùng Bucket4j Rate Limiting
@Component
public class LoginRateLimiterFilter extends OncePerRequestFilter {
    private final Map cache = new ConcurrentHashMap<>();

    @Override
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)
            throws ServletException, IOException {
        if ("/api/auth/login".equals(req.getRequestURI())) {
            String ip = req.getRemoteAddr();
            Bucket bucket = cache.computeIfAbsent(ip, k -> Bucket.builder()
                .addLimit(Bandwidth.classic(5, Refill.intervally(5, Duration.ofMinutes(1))))
                .build());

            if (!bucket.tryConsume(1)) {
                res.setStatus(429); // Too Many Requests
                res.getWriter().write("Quá nhiều lần thử đăng nhập. Vui lòng thử lại sau 1 phút.");
                return;
            }
        }
        chain.doFilter(req, res);
    }
}