Spring Security: Quando Você Descobre Que Segurança Não É Só Senha Forte

8/12/2025 6 min de leitura

#java #spring #seguranca #programacao #web

Lá estava eu, há algumas semanas, tentando implementar autenticação em uma aplicação Spring Boot. Aquele momento clássico onde você pensa “ah, é só adicionar uma senha e pronto”, mas aí você descobre que segurança web é um universo inteiro de conceitos que você nunca imaginou que existiam.

Depois de algumas horas (ou dias) mergulhado na documentação do Spring Security, resolvi escrever sobre essa experiência aqui no blog. Não porque sou especialista no assunto, mas porque às vezes é bom documentar o processo de aprendizado, mesmo que seja só para lembrar depois do que você passou.

O Que É Spring Security?

Spring Security é um framework de segurança para aplicações Java que facilita a implementação de autenticação e autorização. Ele funciona como uma camada de segurança que fica entre sua aplicação e o mundo exterior, controlando quem pode acessar o quê.

A parte interessante é que ele não é só sobre senhas. Ele lida com toda a complexidade de segurança web: CSRF, CORS, sessões, tokens, OAuth, e uma infinidade de outras siglas que você provavelmente nunca ouviu falar antes.

Autenticação vs Autorização

Antes de mergulhar no código, é importante entender a diferença entre esses dois conceitos que sempre confundem:

Autenticação é responder à pergunta “Quem é você?”. É o processo de verificar se o usuário é realmente quem ele diz ser. Login com email e senha é um exemplo clássico.

Autorização é responder à pergunta “O que você pode fazer?”. É o processo de determinar se um usuário autenticado tem permissão para acessar um recurso específico.

Pense assim: autenticação é como mostrar sua identidade na portaria do prédio. Autorização é como descobrir se você tem chave para o apartamento 304.

Configuração Básica

A configuração mais simples possível no Spring Security é assim:

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .permitAll()
            );

        return http.build();
    }
}

Essa configuração diz: “Qualquer coisa em /public/** pode ser acessada por qualquer um, mas para o resto você precisa estar logado. E se não estiver logado, vai para a página de login.”

Simples, né? Até você descobrir que tem mais de 50 métodos de configuração diferentes e cada um tem suas próprias opções.

UserDetailsService: O Coração da Autenticação

Para que o Spring Security saiba como autenticar usuários, você precisa implementar o UserDetailsService:

@Service
public class CustomUserDetailsService implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username)
            .orElseThrow(() -> new UsernameNotFoundException("Usuário não encontrado"));

        return org.springframework.security.core.userdetails.User.builder()
            .username(user.getUsername())
            .password(user.getPassword())
            .authorities(user.getRoles())
            .build();
    }
}

Essa classe é responsável por buscar o usuário no banco de dados e retornar um objeto UserDetails que o Spring Security usa para fazer a autenticação.

Autorização com Anotações

Uma das coisas mais legais do Spring Security é poder usar anotações para controlar acesso:

@RestController
public class UserController {

    @GetMapping("/admin/users")
    @PreAuthorize("hasRole('ADMIN')")
    public List<User> getAllUsers() {
        return userService.findAll();
    }

    @GetMapping("/profile")
    @PreAuthorize("authentication.name == #username")
    public User getProfile(@RequestParam String username) {
        return userService.findByUsername(username);
    }
}

A anotação @PreAuthorize permite expressões SpEL (Spring Expression Language) para definir regras de autorização complexas. É como ter um mini-linguagem de programação só para segurança.

JWT: Quando Você Quer Ser Moderno

Se você quer ser moderno e usar JWT (JSON Web Tokens), a coisa fica um pouco mais complexa:

@Component
public class JwtTokenProvider {

    private String secretKey = "minha-chave-super-secreta";
    private long validityInMilliseconds = 3600000; // 1 hora

    public String createToken(String username, List<String> roles) {
        Claims claims = Jwts.claims().setSubject(username);
        claims.put("roles", roles);

        Date now = new Date();
        Date validity = new Date(now.getTime() + validityInMilliseconds);

        return Jwts.builder()
            .setClaims(claims)
            .setIssuedAt(now)
            .setExpiration(validity)
            .signWith(SignatureAlgorithm.HS256, secretKey)
            .compact();
    }
}

JWT é útil quando você tem aplicações distribuídas ou quando quer que o cliente seja responsável por manter o estado da autenticação. Mas também adiciona complexidade, porque você precisa lidar com refresh tokens, revogação, e outras coisas que não existem quando você usa sessões tradicionais.

O Que Aprendi?

Segurança é um processo, não um produto: Não adianta implementar autenticação e esquecer de HTTPS, validação de entrada, etc.
Documentação é sua amiga: O Spring Security tem uma documentação extensa, mas às vezes você precisa ler duas ou três vezes para entender.
Simplicidade primeiro: Comece com a configuração mais simples possível e vá adicionando complexidade conforme necessário.

Os Problemas Que Encontrei

Configuração confusa: Às vezes você não sabe se o problema é na configuração ou no código
Documentação dispersa: Informações espalhadas em vários lugares
Debugging difícil: Quando algo não funciona, nem sempre é óbvio o porquê
Conceitos abstratos: Muitos conceitos que não são intuitivos para quem está começando

Para Quem Quiser Aprender Mais

Se você quer mergulhar no Spring Security, recomendo começar com a documentação oficial. Ela tem tutoriais passo a passo que ajudam a entender os conceitos básicos.

Também vale a pena dar uma olhada em projetos de exemplo no GitHub. Ver código funcionando ajuda muito a entender como as peças se encaixam.

O Fim da História

Spring Security é uma ferramenta poderosa, mas também complexa. Não é algo que você aprende em uma tarde, mas também não é impossível de dominar com tempo e prática.

A parte mais interessante é que, depois que você entende como funciona, você começa a ver segurança em toda aplicação web que você usa. É como descobrir que existe uma camada invisível controlando tudo, e você finalmente consegue enxergar ela.

E no final das contas, mesmo que você nunca implemente autenticação do zero novamente, entender esses conceitos te torna um desenvolvedor melhor. Porque segurança não é só sobre código, é sobre pensar em como as coisas podem dar errado e como prevenir isso.