Crear configuración inicial de seguridad

Curso de Java Spring Security: Autenticación y Seguridad Web

Introducción

Protección de aplicaciones con Spring Security

Configuración de Spring Security: Autorización y Autenticación

Configuración de Spring Security en Proyectos Java con Gradle

Autenticación Básica con Spring Security por Defecto

Configuración de seguridad

Configuración de Seguridad con Spring Security y Basic Authentication

Funcionamiento del Basic Authentication Filter en Spring Security

Deshabilitar protección CSRF en APIs REST con Spring Security

Configuración de CORS en Spring Security para APIs y Frontend

Configuración de Reglas de Acceso en Spring Security

Creación de usuarios personalizados en Spring Security

Creación y Gestión de Roles y Permisos en Aplicaciones Web

Autenticación con BD

Creación y Gestión de Usuarios en Base de Datos con Spring Security

Implementación de User Detail Service en Spring Security con MySQL

Asignación de Roles y Permisos en Spring Security

Permisos Específicos con Authorities en Spring Security

Seguridad de Métodos en Spring Security: Control de Accesos por Roles

Seguridad con JWT

Creación y Uso de JSON Web Tokens en Java con Auth0

Implementación de Autenticación con JSON Web Tokens en Spring Boot

Validación de JSON Web Tokens con Auth0 en Java

Creación de Filtro de Seguridad JWT en Spring Security

Implementación de JSON Web Token en Spring Security

Próximos pasos

Auditoría de Usuarios con Spring Security y Data JPA

Configuración y Personalización de Spring Security

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

¿Cómo podemos configurar un Security Filter Chain en Spring?

Crear un Security Filter Chain en Spring nos permite manejar la seguridad de nuestras aplicaciones, definiendo cómo se autenticará y autorizará cada petición HTTP. Primero, debemos crear un paquete específico para la configuración de seguridad y una clase donde implementaremos los filtros necesarios.

¿Cómo creamos la configuración inicial de seguridad?

Crear un paquete nuevo: Dentro de la capa web del proyecto, crea un paquete llamado Config.
Anotar la clase con @Configuration: Esto permite que Spring gestione e inyecte automáticamente este bean dentro de la aplicación.
Definir el método Security Filter Chain: Crea un método público que retorne un SecurityFilterChain y reciba un HttpSecurity como parámetro.

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http.build();
    }
}

¿Cómo permitimos o restringimos peticiones HTTP?

Definir las reglas para autorizar peticiones es crucial para proteger una aplicación. Inicialmente, podemos permitir todas las peticiones, y posteriormente, aplicar seguridad ajustando estas configuraciones.

Permitir todas las peticiones: Esto esencialmente elimina las capas de autenticación.
```
http
    .authorizeRequests()
    .anyRequest().permitAll();
```
Requerir autenticación básica para todas las peticiones: Prioriza la seguridad solicitando autenticación en cada acceso.
```
http
    .authorizeRequests()
    .anyRequest().authenticated()
    .and().httpBasic();
```

¿Cómo validamos la configuración con Postman?

Con la configuración inicial realizada, verifica el comportamiento utilizando herramientas como Postman:

Probar sin autorización: Elimina el encabezado de autorización y envía la petición. Si logras recibir una respuesta, significa que la seguridad está desactivada.
Activar Basic Authentication: Configura la autenticación básica con el usuario y contraseña generados por Spring. Observa que las peticiones ahora requieren credenciales válidas.

En el código, aseguramos que las peticiones usen autenticación básica y verificamos el funcionamiento del filtro correspondiente:

http
    .authorizeRequests()
    .anyRequest().authenticated()
    .and().httpBasic();

Al lanzar la aplicación, el filtro BasicAuthenticationFilter gestionará las autenticaciones. Si el header de la autorización no está presente o es incorrecto, la petición será denegada.

¿Qué debemos tener en cuenta al implementar seguridad en Spring?

Gestión de usuarios y contraseñas: Usar User como el usuario por defecto puede ser seguro para desarrollo, pero en producción es crucial personalizar estas credenciales.
Desactivar filtros innecesarios: Spring incluye múltiples filtros por defecto. Solo mantén los relevantes para tu caso y desactiva el resto explícitamente.
Revisar la documentación de Spring Security: Spring es una herramienta poderosa, y conocer sus capacidades nos ayudará a adaptar más funcionalidades.

Este enfoque fortalece tu aplicación contra accesos no autorizados e intenta hacerlo accesible a usuarios válidos. Continúa explorando y ampliando tus habilidades en seguridad con Spring para dominar estos conceptos.

Aportes 15

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Rene Cruz Flores

hace 2 años

La forma de configurar el objeto http que se muestra en la clase está deprecada, aquí una forma en que se puede configurar con los mismos parámetros, pero en la nueva forma:

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

Julián Peña

hace 2 años

Me sirvió de esta forma, la que el profe utiliza en el video esta deprecated

@Configuration
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .anyRequest()
                .permitAll();

        return http.build();
    }
}

Alexis Gutiérrez

hace un año

para el 2023 lo hice de esta manera guaindome de la documentación oficial de spring-security @Configuration public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception{ http .authorizeHttpRequests((authorize) -> authorize .anyRequest().permitAll()); return http.build(); } }

JUAN CARLOS HURTADO MARTINEZ

hace 2 años

En las versiones actuales se puede usar el siguiente ejemplo: @Configuration public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .authorizeHttpRequests((authorize) -> authorize .anyRequest().authenticated() ) .httpBasic(*withDefaults*()); return http.build(); } }

Elioenai Garcia

hace 6 meses

Comparto mi solución del error que sale en esta clase: 😎 \[Spring 3.3.4] 👇 ```java @Configuration @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .authorizeHttpRequests(authorize -> authorize .anyRequest() .authenticated()) .httpBasic(Customizer.withDefaults()); return http.build(); } } ```

John Steven Bernal Gonzalez

hace un año

Me funciono de esta forma, el metodo que ofrece el profesor dice que esta Deprecated

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .anyRequest()
                .authenticated()
                .and()
                .httpBasic(Customizer.withDefaults());

        return http.build();
    }
}

Con Customizer.withDefaults() te proporciona más flexibilidad si necesitas personalizar la configuración básica de autenticación.

Elioenai Garcia

hace 6 meses

Comparto mi solución del error que sale en esta clase: 😎 \[Spring 3.3.4] 👇 @Configuration @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .authorizeHttpRequests(authorize -> authorize .anyRequest() .authenticated()) .httpBasic(Customizer.*withDefaults*()); return http.build(); } }

Omar Léon Villada Granda

hace un año

<https://docs.spring.io/spring-security/reference/6.0-SNAPSHOT/servlet/authorization/authorize-http-requests.html>

Andrés Mauricio Cárdenas Alvarado

hace 17 días

Teniendo en cuenta la evolución de Spring, y dado que lo visto ya esta deprecado se puede generar esta solución para continuar con la ejecución en la máquina local `@Configuration public class SecurityConfig {` `@Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .authorizeHttpRequests( (authorize) -> authorize .anyRequest() .authenticated()).httpBasic(``withDefaults``()); return http.build(); }` `}`

Elioenai Garcia

hace 6 meses

Comparto mi solución del error que sale en esta clase: 😎\[Spring 3.3.4] 👇 ```java @Configuration @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .authorizeHttpRequests(authorize -> authorize .anyRequest() .authenticated()) .httpBasic(Customizer.withDefaults()); return http.build(); } } ```

Alexander Coronell

hace 8 meses

A esta fecha del 2024 construí la clase de la siguiente manera: ```js package com.platzi.pizzeria.web.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.Customizer; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.web.SecurityFilterChain; @Configuration @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http.authorizeHttpRequests((authorize) -> authorize.anyRequest().authenticated()).httpBasic(Customizer.withDefaults()); return http.build(); } } ```

J. Sebastián Botello. H.

hace un año

Si estás usando spring 3.2.2 y java 21 les comparto mir configuración ```java @Configuration @EnableWebSecurity public class SecurityConfig { @Value("${app.security.ignored}") private String\[] authWhiteList; @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http // Disable CSRF since it is a REST API .csrf(AbstractHttpConfigurer::disable) // Enable CORS configuration .cors(cors -> {}) // Configuring session management to be stateless .sessionManagement( sessionManagement -> sessionManagement.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) // Configuring route authorizations .authorizeHttpRequests( auth -> auth // Allow unauthenticated access to Swagger and other required endpoints .requestMatchers(authWhiteList).permitAll() .requestMatchers(PUBLIC\_API + "\*\*").permitAll() .anyRequest().authenticated()) // Add our JWT filter before the username and password authentication filter .addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class); return http.build(); } @Bean public JwtAuthenticationFilter jwtAuthenticationFilter() { return new JwtAuthenticationFilter(); } } ```

juan francisco lencina

hace un año

```java @Configuration public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .authorizeRequests(authorize -> authorize .anyRequest().permitAll()) .httpBasic(withDefaults()); return http.build(); } } ```esta es lo forma que encontre para que funcione. RECUERDA, que al enviar la solicitud en Posman no te olvides de indicar en AUTHORIZATION TYPE No Auth

andres felipe ibarra

hace un año

cordial saludo en el filterchain esta linea http.authorizeHttpRequests().anyRequest().permitAll(); aparece como deprecated? hay alguna alternativa en este caso para controlar este segmento ?

ANDRES ALFONSO MIRA MEJIA

hace 2 años

✅