Convierte tu Aplicación Spring Boot en una Fortaleza con @PreAuthorize 🔒

Mon Feb 17 2025

Desarrollo

¡Hola Chiquis!👋🏻 ¿Quieres que tu aplicación Spring Boot sea tan segura como un búnker de MI6? ¡Con @PreAuthorize, es más fácil de lo que piensas! Imagina tu aplicación como una base secreta, y a @PreAuthorize como tu agente 007 personal, protegiendo cada rincón de tu sistema. ¡Prepárate para convertirte en el 007 de la seguridad en tu aplicación! 🎩🕶️

¿Qué es @PreAuthorize? Es una anotación en Spring Security que permite definir restricciones de acceso a métodos a nivel de servicio basándose en expresiones SpEL (Spring Expression Language). Básicamente, es como tener a tu propio James Bond vigilando y asegurando que solo los agentes autorizados puedan acceder a ciertas partes de tu aplicación.

Imagina que tu aplicación Spring Boot es el MI6, y cada endpoint o método es una misión secreta. No quieres que cualquiera pueda acceder a tus misiones más importantes, así que necesitas a James Bond (en este caso, @PreAuthorize) para asegurar que solo los agentes autorizados (usuarios con los roles correctos) puedan acceder.

@PreAuthorize es una anotación mágica de Spring Security que te permite controlar el acceso a los métodos de tus controladores. Es como poner un guardia de seguridad en la puerta de cada habitación de tu base secreta, asegurando que solo las personas autorizadas puedan entrar.

Misión 1: Configurar Spring Security Primero, necesitas configurar Spring Security en tu aplicación. Es como establecer las normas y protocolos de seguridad en el MI6.

Código de Configuración:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Bean
    @Override
    protected UserDetailsService userDetailsService() {
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("bond")
            .password("007")
            .roles("AGENT")
            .build());
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("m")
            .password("mi6")
            .roles("ADMIN")
            .build());
        return manager;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin().and()
            .httpBasic();
    }
}

En este código, configuramos dos usuarios: bond con el rol AGENT y m con el rol ADMIN.

Misión 2: Proteger Métodos con @PreAuthorize Ahora que tenemos a James Bond listo, necesitamos asignarle algunas misiones. Usaremos @PreAuthorize para proteger nuestros métodos.

Ejemplo de Servicio:

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;

@Service
public class MissionService {

    @PreAuthorize("hasRole('AGENT')")
    public String getSecretMission() {
        return "La misión secreta de Bond: Rescatar al mundo!";
    }

    @PreAuthorize("hasRole('ADMIN')")
    public String getTopSecretMission() {
        return "Misión ultrasecreta: ¡Sólo para ojos de M!";
    }
}

En este ejemplo, usamos @PreAuthorize para especificar que solo los usuarios con el rol AGENT pueden acceder al método getSecretMission y solo los usuarios con el rol ADMIN pueden acceder al método getTopSecretMission.

Misión 3: Probar la Seguridad Para asegurarnos de que James Bond está haciendo su trabajo, probemos el acceso a nuestros métodos protegidos.

Ejemplo de Prueba:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

@SpringJUnitConfig(classes = {SecurityConfig.class, MissionService.class})
public class MissionServiceTest {

    @Autowired
    private MissionService missionService;

    @Test
    @WithMockUser(username = "bond", roles = {"AGENT"})
    public void whenAgentAccessesSecretMission_thenSuccess() {
        assertEquals("La misión secreta de Bond: Rescatar al mundo!", missionService.getSecretMission());
    }

    @Test
    @WithMockUser(username = "bond", roles = {"AGENT"})
    public void whenAgentAccessesTopSecretMission_thenDenied() {
        assertThrows(SecurityException.class, () -> missionService.getTopSecretMission());
    }

    @Test
    @WithMockUser(username = "m", roles = {"ADMIN"})
    public void whenAdminAccessesTopSecretMission_thenSuccess() {
        assertEquals("Misión ultrasecreta: ¡Sólo para ojos de M!", missionService.getTopSecretMission());
    }
}

En estas pruebas, verificamos que:

Un usuario con rol AGENT puede acceder a getSecretMission.
Un usuario con rol AGENT no puede acceder a getTopSecretMission.
Un usuario con rol ADMIN puede acceder a getTopSecretMission.

¡Expulsión!

**Misión: Cada método de tu controlador es una misión.
Agente 007 (@PreAuthorize): Evalúa si el agente (usuario) tiene los permisos necesarios para completar la misión.
Permisos: Los permisos son como las credenciales de acceso de Bond. Pueden ser tan simples como “ROLE_USER” o tan complejos como “hasAuthority(‘ADMIN’) and #user.isActivated()”.
Expulsión: Si el agente no tiene los permisos adecuados, es expulsado (se produce un error de acceso denegado).
Ejemplo:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Bean
    @Override
    protected UserDetailsService userDetailsService() {
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("bond")
            .password("007")
            .roles("AGENT")
            .build());
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("m")
            .password("mi6")
            .roles("ADMIN")
            .build());
        return manager;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin().and()
            .httpBasic();
    }
}

En este ejemplo, solo los usuarios con el rol “ADMIN” pueden acceder al método getSecretDocuments. Es como si solo M y Moneypenny pudieran entrar en la sala de operaciones.

¿Por qué es tan genial @PreAuthorize?

Flexibilidad: Puedes crear reglas de autorización muy específicas y personalizadas.
Facilidad de uso: Se integra perfectamente con Spring Security.
Seguridad: Protege tus datos y recursos de forma efectiva.

Más allá de Bond: Otras características de Spring Security

Roles: Define diferentes roles para tus usuarios (ADMIN, USER, GUEST, etc.).
Expresiones SpEL: Utiliza el lenguaje de expresiones SpEL para crear reglas de autorización más complejas.
AuthenticationManager: Gestiona la autenticación de usuarios.
AccessControl: Controla el acceso a los recursos de tu aplicación.

Recuerda: La seguridad es un proceso continuo. Mantén tu aplicación actualizada, realiza auditorías de seguridad regularmente y educa a tus usuarios sobre buenas prácticas de seguridad.

Conclusión Proteger tu aplicación Spring Boot con @PreAuthorize es tan fácil como tener a James Bond vigilando tus endpoints. Con esta poderosa anotación, puedes asegurar que solo los usuarios autorizados tengan acceso a las partes críticas de tu aplicación. 😊🚀

¡Gracias por leer! 👇🏻 🚀 ¿Te ha gustado? Comparte tu opinión. Artículo completo, visita: https://community.aws/@orlidun https://lnkd.in/ewtCN2Mn https://lnkd.in/eAjM_Smy 👩💻 https://lnkd.in/eKvu-BHe https://dev.to/orlidev https://lnkd.in/ecHHabTD https://pin.it/2BuZ9N4n8 https://linktr.ee/orlidevs ¡No te lo pierdas!

Referencias: Imágenes creadas con: Copilot ( microsoft.com )

#PorUnMillóndeAmigos #MakeYourselfVisible

Convierte tu Aplicación Spring Boot en una Fortaleza con @PreAuthorize 🔒

https://my-million-friend-blog.vercel.app/blog/post-213/