Capítulo 2: Autenticação Básica

Introdução

Este capítulo ensina como configurar os métodos de autenticação mais comuns: Form Login e HTTP Basic. Você também aprenderá a armazenar usuários no banco de dados com senhas seguras.

---

🎯 Objetivos do Capítulo

Ao final deste capítulo, você saberá:

1. ✅ Configurar autenticação por formulário
2. ✅ Configurar HTTP Basic para APIs
3. ✅ Implementar UserDetailsService com banco de dados
4. ✅ Usar BCrypt para codificar senhas
5. ✅ Personalizar as páginas de login/logout

---

1. Configuração Básica

Dependências

<!-- 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 Thymeleaf + Security -->
    <dependency>
        <groupId>org.thymeleaf.extras</groupId>
        <artifactId>thymeleaf-extras-springsecurity6</artifactId>
    </dependency>
</dependencies>

Configuração 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. Usuários em Memória (Teste)

Somente para Desenvolvimento

@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();
    }
}

atenção

InMemoryUserDetailsManager é apenas para testes e desenvolvimento. Em produção, utilize um banco de dados!

---

3. Usuários no Banco de Dados

3.1 Entidade 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 Entidade 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 acessar a entidade 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(
                "Usuário não encontrado: " + username
            ));

        return new CustomUserDetails(user);
    }
}

3.6 Configuração com o Banco de Dados

@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. Serviço de Cadastro

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) {
        // Verificações
        if (userRepository.existsByUsername(username)) {
            throw new RuntimeException("Este nome de usuário já existe");
        }
        if (userRepository.existsByEmail(email)) {
            throw new RuntimeException("Este e-mail já está em uso");
        }

        // Criar o usuário
        User user = new User();
        user.setUsername(username);
        user.setEmail(email);
        user.setPassword(passwordEncoder.encode(password));  // ← Codificação!
        user.setEnabled(true);

        // Atribuir o papel USER por padrão
        Role userRole = roleRepository.findByName("ROLE_USER")
            .orElseThrow(() -> new RuntimeException("Papel ROLE_USER não encontrado"));
        user.getRoles().add(userRole);

        return userRepository.save(user);
    }

    @Transactional
    public void promoteToAdmin(Long userId) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new RuntimeException("Usuário não encontrado"));

        Role adminRole = roleRepository.findByName("ROLE_ADMIN")
            .orElseThrow(() -> new RuntimeException("Papel ROLE_ADMIN não encontrado"));

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

---

5. HTTP Basic para API

Configuração

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.disable())  // Desabilitar 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();
    }
}

Teste com cURL

# Sem autenticação
curl http://localhost:8080/api/users
# 401 Unauthorized

# Com autenticação
curl -u user:password http://localhost:8080/api/users
# 200 OK + dados

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

cuidado

HTTP Basic envia as credenciais codificadas em Base64 (NÃO criptografadas!). SEMPRE use HTTPS em produção!

---

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", "Cadastro realizado com sucesso!");
            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>Login</title>
    <link rel="stylesheet" th:href="@{/css/style.css}">
</head>
<body>
    <div class="login-container">
        <h1>Login</h1>
        
        <!-- Mensagens -->
        <div th:if="${param.error}" class="alert alert-danger">
            Nome de usuário ou senha incorretos.
        </div>
        <div th:if="${param.logout}" class="alert alert-info">
            Você foi desconectado.
        </div>
        <div th:if="${success}" class="alert alert-success" th:text="${success}"></div>
        
        <!-- Formulário -->
        <form th:action="@{/login}" method="post">
            <div class="form-group">
                <label for="username">Nome de usuário</label>
                <input type="text" id="username" name="username" required>
            </div>
            
            <div class="form-group">
                <label for="password">Senha</label>
                <input type="password" id="password" name="password" required>
            </div>
            
            <div class="form-group">
                <label>
                    <input type="checkbox" name="remember-me"> Lembrar-me
                </label>
            </div>
            
            <button type="submit">Entrar</button>
        </form>
        
        <p>Ainda não tem conta? <a th:href="@{/register}">Cadastre-se</a></p>
    </div>
</body>
</html>

Configuração Remember-Me

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        // ... outras configs
        .rememberMe(remember -> remember
            .key("uniqueAndSecretKey")  // Chave de assinatura
            .tokenValiditySeconds(86400 * 7)  // 7 dias
            .userDetailsService(userDetailsService)
        )
        .build();
}

---

7. Acessar o Usuário Logado

Em um Controller

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

    // Método 1: Principal
    @GetMapping("/me")
    public String getCurrentUser(Principal principal) {
        return "Logado 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 (em qualquer lugar)
    @GetMapping("/static")
    public String getFromContext() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        return auth.getName();
    }
}

No Thymeleaf

<!-- Com thymeleaf-extras-springsecurity6 -->
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/extras/spring-security">
      
<!-- Exibir nome do usuário -->
<p>Bem-vindo, <span sec:authentication="name">Usuário</span>!</p>

<!-- Exibir conforme o papel -->
<div sec:authorize="hasRole('ADMIN')">
    <a href="/admin">Administração</a>
</div>

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

<!-- Exibir se autenticado -->
<div sec:authorize="isAuthenticated()">
    <form th:action="@{/logout}" method="post">
        <button type="submit">Sair</button>
    </form>
</div>

<!-- Exibir se NÃO autenticado -->
<div sec:authorize="isAnonymous()">
    <a href="/login">Login</a>
</div>

---

8. Tratamento de Erros

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\": \"Acesso negado\"}");
        } else {
            // Para páginas web
            response.sendRedirect("/access-denied");
        }
    }
}

Configuração

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        // ... outras configs
        .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\": \"Não autenticado\"}");
                } else {
                    response.sendRedirect("/login");
                }
            })
        )
        .build();
}

---

9. Dados Iniciais

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) {
        // Criar papéis se não existirem
        if (roleRepository.count() == 0) {
            roleRepository.save(new Role("ROLE_USER"));
            roleRepository.save(new Role("ROLE_ADMIN"));
            roleRepository.save(new Role("ROLE_MANAGER"));
        }

        // Criar admin padrão se não houver usuário
        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. Resumo

Pontos-Chave

Conceito	Descrição
Form Login	Autenticação via formulário web
HTTP Basic	Header Authorization para API
UserDetailsService	Interface para carregar usuários
PasswordEncoder	Codificação de senhas (BCrypt)
CustomUserDetails	Adaptar User para UserDetails

Configuração 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 senhas com BCrypt
✅ Implementar UserDetailsService para o banco de dados
✅ Criar CustomUserDetails se necessário
✅ Configurar páginas de login/logout
✅ Tratar erros de acesso
✅ Criar papéis e usuários iniciais

---

🎯 Próximo Passo

A autenticação por sessão é perfeita para aplicações web, mas para APIs REST modernas, JWT é o padrão.

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

---

⬅️ Voltar ao Módulo 8