Capítulo 2: Autenticación Básica

Introducción

Este capítulo le enseña a configurar los métodos de autenticación más comunes: Form Login y HTTP Basic. También aprenderá a almacenar usuarios en base de datos con contraseñas seguras.

---

🎯 Objetivos del Capítulo

Al final de este capítulo, usted sabrá:

1. ✅ Configurar la autenticación por formulario
2. ✅ Configurar HTTP Basic para las API
3. ✅ Implementar UserDetailsService con la base de datos
4. ✅ Utilizar BCrypt para codificar las contraseñas
5. ✅ Personalizar las páginas de login/logout

---

1. Configuración Básica

Dependencias

<!-- pom.xml -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!-- Para extras de Thymeleaf + Security -->
    <dependency>
        <groupId>org.thymeleaf.extras</groupId>
        <artifactId>thymeleaf-extras-springsecurity6</artifactId>
    </dependency>
</dependencies>

Configuración Mínima

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/", "/home", "/css/**", "/js/**").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .defaultSuccessUrl("/dashboard")
                .permitAll()
            )
            .logout(logout -> logout
                .logoutSuccessUrl("/login?logout")
                .permitAll()
            )
            .build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

---

2. Usuarios en Memoria (Test)

Solo para Desarrollo

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .authorizeHttpRequests(auth -> auth
                .anyRequest().authenticated()
            )
            .formLogin(Customizer.withDefaults())
            .build();
    }

    @Bean
    public UserDetailsService userDetailsService(PasswordEncoder encoder) {
        UserDetails user = User.builder()
            .username("user")
            .password(encoder.encode("password"))
            .roles("USER")
            .build();

        UserDetails admin = User.builder()
            .username("admin")
            .password(encoder.encode("admin123"))
            .roles("ADMIN", "USER")
            .build();

        return new InMemoryUserDetailsManager(user, admin);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

aviso

InMemoryUserDetailsManager es solo para pruebas y desarrollo. ¡En producción, utilice una base de datos!

---

3. Usuarios en Base de Datos

3.1 Entidad User

@Entity
@Table(name = "users")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String username;

    @Column(nullable = false)
    private String password;

    @Column(unique = true, nullable = false)
    private String email;

    private boolean enabled = true;

    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles = new HashSet<>();
}

3.2 Entidad Role

@Entity
@Table(name = "roles")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Role {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String name;  // ROLE_USER, ROLE_ADMIN

    public Role(String name) {
        this.name = name;
    }
}

3.3 Repository

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
    boolean existsByUsername(String username);
    boolean existsByEmail(String email);
}

@Repository
public interface RoleRepository extends JpaRepository<Role, Long> {
    Optional<Role> findByName(String name);
}

3.4 CustomUserDetails

public class CustomUserDetails implements UserDetails {

    private final User user;

    public CustomUserDetails(User user) {
        this.user = user;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return user.getRoles().stream()
            .map(role -> new SimpleGrantedAuthority(role.getName()))
            .collect(Collectors.toList());
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getUsername();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return user.isEnabled();
    }

    // Para acceder a la entidad User completa
    public User getUser() {
        return user;
    }
}

3.5 CustomUserDetailsService

@Service
@RequiredArgsConstructor
public class CustomUserDetailsService implements UserDetailsService {

    private final UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username)
            .orElseThrow(() -> new UsernameNotFoundException(
                "Usuario no encontrado: " + username
            ));

        return new CustomUserDetails(user);
    }
}

3.6 Configuración con la BDD

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig {

    private final CustomUserDetailsService userDetailsService;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/", "/register", "/css/**", "/js/**").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .defaultSuccessUrl("/dashboard")
                .permitAll()
            )
            .logout(logout -> logout
                .logoutSuccessUrl("/login?logout")
                .deleteCookies("JSESSIONID")
                .permitAll()
            )
            .userDetailsService(userDetailsService)
            .build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authenticationManager(
            AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
}

---

4. Servicio de Registro

UserService

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;
    private final RoleRepository roleRepository;
    private final PasswordEncoder passwordEncoder;

    @Transactional
    public User registerUser(String username, String email, String password) {
        // Verificaciones
        if (userRepository.existsByUsername(username)) {
            throw new RuntimeException("Este nombre de usuario ya existe");
        }
        if (userRepository.existsByEmail(email)) {
            throw new RuntimeException("Este correo electrónico ya está en uso");
        }

        // Crear el usuario
        User user = new User();
        user.setUsername(username);
        user.setEmail(email);
        user.setPassword(passwordEncoder.encode(password));  // ← ¡Codificación!
        user.setEnabled(true);

        // Asignar el rol USER por defecto
        Role userRole = roleRepository.findByName("ROLE_USER")
            .orElseThrow(() -> new RuntimeException("Rol ROLE_USER no encontrado"));
        user.getRoles().add(userRole);

        return userRepository.save(user);
    }

    @Transactional
    public void promoteToAdmin(Long userId) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new RuntimeException("Usuario no encontrado"));

        Role adminRole = roleRepository.findByName("ROLE_ADMIN")
            .orElseThrow(() -> new RuntimeException("Rol ROLE_ADMIN no encontrado"));

        user.getRoles().add(adminRole);
        userRepository.save(user);
    }
}

---

5. HTTP Basic para API

Configuración

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.disable())  // Desactivar para API REST
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .requestMatchers("/api/**").authenticated()
            )
            .httpBasic(Customizer.withDefaults())  // ← HTTP Basic
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .build();
    }
}

Prueba con cURL

# Sin autenticación
curl http://localhost:8080/api/users
# 401 Unauthorized

# Con autenticación
curl -u user:password http://localhost:8080/api/users
# 200 OK + datos

# Con header explícito
curl -H "Authorization: Basic dXNlcjpwYXNzd29yZA==" http://localhost:8080/api/users

precaución

HTTP Basic envía las credenciales codificadas en Base64 (¡NO cifradas!). Utilice SIEMPRE HTTPS en producción.

---

6. Páginas de Login Personalizadas

Controller

@Controller
public class AuthController {

    @GetMapping("/login")
    public String loginPage() {
        return "login";  // templates/login.html
    }

    @GetMapping("/register")
    public String registerPage(Model model) {
        model.addAttribute("user", new RegisterRequest());
        return "register";
    }

    @PostMapping("/register")
    public String register(@Valid @ModelAttribute("user") RegisterRequest request,
                          BindingResult result,
                          RedirectAttributes redirectAttributes) {
        if (result.hasErrors()) {
            return "register";
        }

        try {
            userService.registerUser(
                request.getUsername(),
                request.getEmail(),
                request.getPassword()
            );
            redirectAttributes.addFlashAttribute("success", "¡Registro exitoso!");
            return "redirect:/login";
        } catch (Exception e) {
            result.rejectValue("username", "error", e.getMessage());
            return "register";
        }
    }
}

Template Login (Thymeleaf)

<!-- templates/login.html -->
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Inicio de sesión</title>
    <link rel="stylesheet" th:href="@{/css/style.css}">
</head>
<body>
    <div class="login-container">
        <h1>Inicio de sesión</h1>
        
        <!-- Mensajes -->
        <div th:if="${param.error}" class="alert alert-danger">
            Nombre de usuario o contraseña incorrectos.
        </div>
        <div th:if="${param.logout}" class="alert alert-info">
            Usted ha cerrado sesión.
        </div>
        <div th:if="${success}" class="alert alert-success" th:text="${success}"></div>
        
        <!-- Formulario -->
        <form th:action="@{/login}" method="post">
            <div class="form-group">
                <label for="username">Nombre de usuario</label>
                <input type="text" id="username" name="username" required>
            </div>
            
            <div class="form-group">
                <label for="password">Contraseña</label>
                <input type="password" id="password" name="password" required>
            </div>
            
            <div class="form-group">
                <label>
                    <input type="checkbox" name="remember-me"> Recordarme
                </label>
            </div>
            
            <button type="submit">Iniciar sesión</button>
        </form>
        
        <p>¿Aún no tiene cuenta? <a th:href="@{/register}">Registrarse</a></p>
    </div>
</body>
</html>

Configuración Remember-Me

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        // ... otras configuraciones
        .rememberMe(remember -> remember
            .key("uniqueAndSecretKey")  // Clave de firma
            .tokenValiditySeconds(86400 * 7)  // 7 días
            .userDetailsService(userDetailsService)
        )
        .build();
}

---

7. Acceder al Usuario Conectado

En un Controller

@RestController
@RequestMapping("/api")
public class ProfileController {

    // Método 1: Principal
    @GetMapping("/me")
    public String getCurrentUser(Principal principal) {
        return "Conectado como: " + principal.getName();
    }

    // Método 2: Authentication
    @GetMapping("/profile")
    public Map<String, Object> getProfile(Authentication authentication) {
        CustomUserDetails userDetails = (CustomUserDetails) authentication.getPrincipal();
        User user = userDetails.getUser();

        return Map.of(
            "username", user.getUsername(),
            "email", user.getEmail(),
            "roles", authentication.getAuthorities()
        );
    }

    // Método 3: @AuthenticationPrincipal
    @GetMapping("/details")
    public User getDetails(@AuthenticationPrincipal CustomUserDetails userDetails) {
        return userDetails.getUser();
    }

    // Método 4: SecurityContextHolder (en cualquier parte)
    @GetMapping("/static")
    public String getFromContext() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        return auth.getName();
    }
}

En Thymeleaf

<!-- Con thymeleaf-extras-springsecurity6 -->
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/extras/spring-security">
      
<!-- Mostrar el nombre de usuario -->
<p>Bienvenido, <span sec:authentication="name">Usuario</span>!</p>

<!-- Mostrar según el rol -->
<div sec:authorize="hasRole('ADMIN')">
    <a href="/admin">Administración</a>
</div>

<div sec:authorize="hasRole('USER')">
    <a href="/profile">Mi Perfil</a>
</div>

<!-- Mostrar si está autenticado -->
<div sec:authorize="isAuthenticated()">
    <form th:action="@{/logout}" method="post">
        <button type="submit">Cerrar sesión</button>
    </form>
</div>

<!-- Mostrar si NO está autenticado -->
<div sec:authorize="isAnonymous()">
    <a href="/login">Iniciar sesión</a>
</div>

---

8. Gestión de Errores

AccessDeniedHandler Personalizado

@Component
public class CustomAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request,
                      HttpServletResponse response,
                      AccessDeniedException ex) throws IOException {
        
        // Para API REST
        if (request.getRequestURI().startsWith("/api/")) {
            response.setContentType("application/json");
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
            response.getWriter().write("{\"error\": \"Acceso denegado\"}");
        } else {
            // Para páginas web
            response.sendRedirect("/access-denied");
        }
    }
}

Configuración

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        // ... otras configuraciones
        .exceptionHandling(ex -> ex
            .accessDeniedHandler(customAccessDeniedHandler)
            .authenticationEntryPoint((request, response, authException) -> {
                if (request.getRequestURI().startsWith("/api/")) {
                    response.setContentType("application/json");
                    response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                    response.getWriter().write("{\"error\": \"No autenticado\"}");
                } else {
                    response.sendRedirect("/login");
                }
            })
        )
        .build();
}

---

9. Datos Iniciales

DataInitializer

@Component
@RequiredArgsConstructor
public class DataInitializer implements CommandLineRunner {

    private final RoleRepository roleRepository;
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;

    @Override
    @Transactional
    public void run(String... args) {
        // Crear los roles si no existen
        if (roleRepository.count() == 0) {
            roleRepository.save(new Role("ROLE_USER"));
            roleRepository.save(new Role("ROLE_ADMIN"));
            roleRepository.save(new Role("ROLE_MANAGER"));
        }

        // Crear un admin por defecto si no hay usuarios
        if (userRepository.count() == 0) {
            Role adminRole = roleRepository.findByName("ROLE_ADMIN").orElseThrow();
            Role userRole = roleRepository.findByName("ROLE_USER").orElseThrow();

            User admin = new User();
            admin.setUsername("admin");
            admin.setEmail("admin@example.com");
            admin.setPassword(passwordEncoder.encode("admin123"));
            admin.setEnabled(true);
            admin.setRoles(Set.of(adminRole, userRole));
            
            userRepository.save(admin);
        }
    }
}

---

10. Resumen

Puntos Clave

Concepto	Descripción
Form Login	Autenticación por formulario web
HTTP Basic	Header Authorization para API
UserDetailsService	Interfaz para cargar los usuarios
PasswordEncoder	Codificación de contraseñas (BCrypt)
CustomUserDetails	Adaptar User a UserDetails

Configuración Tipo

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/public/**").permitAll()
            .requestMatchers("/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
        )
        .formLogin(form -> form
            .loginPage("/login")
            .permitAll()
        )
        .logout(logout -> logout.permitAll())
        .build();
}

Checklist

✅ Codificar las contraseñas con BCrypt
✅ Implementar UserDetailsService para la BDD
✅ Crear CustomUserDetails si es necesario
✅ Configurar las páginas de login/logout
✅ Gestionar los errores de acceso
✅ Crear los roles y usuarios iniciales

---

🎯 Próximo Paso

La autenticación por sesión es perfecta para aplicaciones web, pero para las API REST modernas, JWT es el estándar.

➡️ Capítulo 3: JWT (JSON Web Tokens)

---

⬅️ Volver al Módulo 8