Capítulo 5: Segurança Avançada

Introdução

A autenticação é apenas a primeira linha de defesa. Este capítulo aborda os mecanismos de proteção avançada contra ataques comuns e o gerenciamento refinado de autorizações.

---

🎯 Objetivos do Capítulo

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

1. ✅ Proteger contra ataques CSRF
2. ✅ Configurar CORS para APIs
3. ✅ Utilizar @PreAuthorize e @Secured
4. ✅ Implementar um sistema RBAC
5. ✅ Configurar headers de segurança

---

1. Proteção CSRF

O que é CSRF?

Cross-Site Request Forgery: Um atacante faz com que um usuário autenticado execute ações sem o seu consentimento.

Proteção Padrão

O Spring Security ativa CSRF por padrão para aplicações web:

// Por padrão, CSRF está ATIVADO
// O token CSRF é automaticamente verificado em POST, PUT, DELETE

Token CSRF em Formulários

<!-- Thymeleaf - automático com th:action -->
<form th:action="@{/transfer}" method="post">
    <!-- O token CSRF é adicionado automaticamente -->
    <input type="hidden" name="_csrf" th:value="${_csrf.token}"/>
    ...
</form>

<!-- Ou explicitamente -->
<form action="/transfer" method="post">
    <input type="hidden" 
           th:name="${_csrf.parameterName}" 
           th:value="${_csrf.token}"/>
    ...
</form>

CSRF para API REST

Para APIs REST stateless com JWT, desative o CSRF:

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        .csrf(csrf -> csrf.disable())  // ← Desativar para API REST
        .sessionManagement(session -> session
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
        )
        // ...
        .build();
}

atenção

Desative o CSRF apenas se você estiver usando autenticação stateless (JWT, OAuth2). Para sessões, mantenha-o ativado!

CSRF Seletivo

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        .csrf(csrf -> csrf
            .ignoringRequestMatchers("/api/**")  // Desativado para /api/
            .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
        )
        .build();
}

---

2. Configuração CORS

O que é CORS?

Cross-Origin Resource Sharing: Controla quais domínios podem acessar sua API.

Frontend: https://app.example.com
Backend:  https://api.example.com  ← Domínio diferente!

Sem CORS configurado → Requisições bloqueadas pelo navegador

Configuração Global

@Configuration
public class CorsConfig {

    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        
        // Origens permitidas
        configuration.setAllowedOrigins(List.of(
            "http://localhost:3000",
            "https://app.example.com"
        ));
        
        // Métodos HTTP permitidos
        configuration.setAllowedMethods(List.of(
            "GET", "POST", "PUT", "DELETE", "OPTIONS"
        ));
        
        // Headers permitidos
        configuration.setAllowedHeaders(List.of(
            "Authorization",
            "Content-Type",
            "X-Requested-With"
        ));
        
        // Permitir credentials (cookies, Authorization header)
        configuration.setAllowCredentials(true);
        
        // Tempo de cache do preflight
        configuration.setMaxAge(3600L);
        
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

Integração com Spring Security

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        .cors(Customizer.withDefaults())  // ← Ativar CORS
        .csrf(csrf -> csrf.disable())
        // ...
        .build();
}

CORS por Controller

@RestController
@RequestMapping("/api/public")
@CrossOrigin(origins = "http://localhost:3000")  // ← Específico
public class PublicController {
    // ...
}

// Ou por método
@GetMapping("/data")
@CrossOrigin(origins = "*", maxAge = 3600)
public Data getData() {
    // ...
}

---

3. Method-Level Security

Ativação

@Configuration
@EnableWebSecurity
@EnableMethodSecurity  // ← Ativa @PreAuthorize, @PostAuthorize, @Secured
public class SecurityConfig {
    // ...
}

@PreAuthorize

Verifica ANTES da execução do método:

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

    // Verificar um papel
    @GetMapping("/admin/users")
    @PreAuthorize("hasRole('ADMIN')")
    public List<User> getAllUsers() { ... }

    // Verificar múltiplos papéis
    @DeleteMapping("/users/{id}")
    @PreAuthorize("hasAnyRole('ADMIN', 'MANAGER')")
    public void deleteUser(@PathVariable Long id) { ... }

    // Verificar uma authority/permissão
    @PostMapping("/users")
    @PreAuthorize("hasAuthority('CREATE_USER')")
    public User createUser(@RequestBody User user) { ... }

    // Expressão complexa
    @PutMapping("/users/{id}")
    @PreAuthorize("hasRole('ADMIN') or #id == authentication.principal.id")
    public User updateUser(@PathVariable Long id, @RequestBody User user) { ... }

    // Acesso ao objeto authentication
    @GetMapping("/me")
    @PreAuthorize("isAuthenticated()")
    public User getCurrentUser(Authentication auth) { ... }
}

@PostAuthorize

Verifica APÓS a execução (útil para verificar o resultado):

@GetMapping("/users/{id}")
@PostAuthorize("returnObject.username == authentication.name or hasRole('ADMIN')")
public User getUser(@PathVariable Long id) {
    return userRepository.findById(id).orElseThrow();
}

@Secured (Legado)

Mais simples, porém menos flexível:

@Secured("ROLE_ADMIN")
public void adminOnly() { ... }

@Secured({"ROLE_ADMIN", "ROLE_MANAGER"})
public void adminOrManager() { ... }

Expressões SpEL Disponíveis

Expressão	Descrição
hasRole('ROLE')	Possui o papel (adiciona ROLE_ automaticamente)
hasAnyRole('R1', 'R2')	Possui um dos papéis
hasAuthority('AUTH')	Possui a authority exata
hasAnyAuthority('A1', 'A2')	Possui uma das authorities
isAuthenticated()	Está autenticado
isAnonymous()	Não está autenticado
isFullyAuthenticated()	Não autenticado via remember-me
permitAll	Sempre permitido
denyAll	Sempre negado
#paramName	Acesso aos parâmetros
returnObject	Resultado (@PostAuthorize)
authentication	Objeto Authentication
principal	O usuário (UserDetails)

---

4. Sistema RBAC (Role-Based Access Control)

Modelo de Dados

Entidades

@Entity
@Table(name = "permissions")
@Data
public class Permission {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(unique = true, nullable = false)
    private String name;  // READ_USERS, WRITE_USERS, DELETE_USERS
}

@Entity
@Table(name = "roles")
@Data
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(unique = true, nullable = false)
    private String name;  // ROLE_ADMIN, ROLE_USER, ROLE_MANAGER
    
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "role_permissions",
        joinColumns = @JoinColumn(name = "role_id"),
        inverseJoinColumns = @JoinColumn(name = "permission_id")
    )
    private Set<Permission> permissions = new HashSet<>();
}

UserDetails com Permissões

public class CustomUserDetails implements UserDetails {
    private final User user;

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        Set<GrantedAuthority> authorities = new HashSet<>();
        
        for (Role role : user.getRoles()) {
            // Adicionar o papel
            authorities.add(new SimpleGrantedAuthority(role.getName()));
            
            // Adicionar as permissões do papel
            for (Permission permission : role.getPermissions()) {
                authorities.add(new SimpleGrantedAuthority(permission.getName()));
            }
        }
        
        return authorities;
    }
    // ...
}

Utilização

// Por papel
@PreAuthorize("hasRole('ADMIN')")
public void adminAction() { }

// Por permissão
@PreAuthorize("hasAuthority('DELETE_USERS')")
public void deleteUser(Long id) { }

// Combinação
@PreAuthorize("hasRole('MANAGER') and hasAuthority('APPROVE_ORDERS')")
public void approveOrder(Long orderId) { }

---

5. Headers de Segurança

Configuração

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        .headers(headers -> headers
            // Content Security Policy
            .contentSecurityPolicy(csp -> csp
                .policyDirectives("default-src 'self'; script-src 'self'")
            )
            // X-Frame-Options (clickjacking)
            .frameOptions(frame -> frame.sameOrigin())
            // X-Content-Type-Options
            .contentTypeOptions(Customizer.withDefaults())
            // X-XSS-Protection
            .xssProtection(xss -> xss.headerValue(XXssProtectionHeaderWriter.HeaderValue.ENABLED_MODE_BLOCK))
            // HSTS (HTTPS obrigatório)
            .httpStrictTransportSecurity(hsts -> hsts
                .includeSubDomains(true)
                .maxAgeInSeconds(31536000)
            )
        )
        .build();
}

Headers Resultantes

Content-Security-Policy: default-src 'self'; script-src 'self'
X-Frame-Options: SAMEORIGIN
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Strict-Transport-Security: max-age=31536000; includeSubDomains

---

6. Proteção Contra Ataques

Brute Force (Limite de Tentativas)

@Service
public class LoginAttemptService {
    private final Cache<String, Integer> attemptsCache = CacheBuilder.newBuilder()
        .expireAfterWrite(1, TimeUnit.HOURS)
        .build();

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

    public void loginFailed(String key) {
        int attempts = attemptsCache.get(key, () -> 0);
        attemptsCache.put(key, attempts + 1);
    }

    public boolean isBlocked(String key) {
        return attemptsCache.get(key, () -> 0) >= 5;
    }
}

Integração com a Autenticação

@Component
@RequiredArgsConstructor
public class AuthenticationFailureListener 
        implements ApplicationListener<AuthenticationFailureBadCredentialsEvent> {

    private final LoginAttemptService loginAttemptService;

    @Override
    public void onApplicationEvent(AuthenticationFailureBadCredentialsEvent event) {
        String username = (String) event.getAuthentication().getPrincipal();
        loginAttemptService.loginFailed(username);
    }
}

@Component
@RequiredArgsConstructor
public class AuthenticationSuccessListener 
        implements ApplicationListener<AuthenticationSuccessEvent> {

    private final LoginAttemptService loginAttemptService;

    @Override
    public void onApplicationEvent(AuthenticationSuccessEvent event) {
        String username = event.getAuthentication().getName();
        loginAttemptService.loginSucceeded(username);
    }
}

---

7. Auditoria de Segurança

Logging de Eventos

@Component
@Slf4j
public class SecurityAuditListener {

    @EventListener
    public void onSuccess(AuthenticationSuccessEvent event) {
        log.info("LOGIN SUCCESS: {} at {}", 
            event.getAuthentication().getName(),
            LocalDateTime.now());
    }

    @EventListener
    public void onFailure(AuthenticationFailureBadCredentialsEvent event) {
        log.warn("LOGIN FAILED: {} at {}", 
            event.getAuthentication().getPrincipal(),
            LocalDateTime.now());
    }

    @EventListener
    public void onAccessDenied(AuthorizationDeniedEvent event) {
        log.warn("ACCESS DENIED: {} tried to access {}", 
            event.getAuthentication().get().getName(),
            event.getSource());
    }
}

---

8. Resumo

Proteções Essenciais

Proteção	Contra	Configuração
CSRF	Requisições forjadas	Ativado por padrão (desativar para API REST)
CORS	Requisições cross-origin	cors(Customizer.withDefaults())
XSS	Scripts maliciosos	Headers + CSP
Clickjacking	Frames maliciosos	X-Frame-Options
Brute Force	Ataques de força bruta	Limitação de tentativas

Method Security

@PreAuthorize("hasRole('ADMIN')")           // Por papel
@PreAuthorize("hasAuthority('DELETE_USER')") // Por permissão
@PreAuthorize("#id == authentication.principal.id") // Por expressão

Checklist de Segurança

✅ CSRF ativado para sessões
✅ CORS configurado para a API
✅ Senhas codificadas (BCrypt)
✅ Headers de segurança configurados
✅ @PreAuthorize em métodos sensíveis
✅ Auditoria de eventos de segurança
✅ Proteção contra brute force

---

🎯 Próximo Passo

Agora você já tem toda a teoria! Hora de praticar com os exercícios práticos.

➡️ TP8.1: Autenticação Form Login

---

⬅️ Voltar ao Módulo 8