Curso de Spring Boot | Login con Spring Security y securizar API

Por 9.99€ al mes tendrás acceso completo a todos los cursos. Sin matrícula ni permanencia.

Securizar API con autentificación básica

Tras realizar el login, si este tiene éxito, podremos almacenar el usuario y la contraseña en el cliente y enviar estos datos en la cabecera de cada petición.

Flujo de una petición de autentificación

Ejemplo de petición que haremos a nuestra aplicación de Spring

axios.post("http://localhost:8080/login",{},
  {
    headers: {
      "Content-Type": "application/json",
      Authorization: "basic " + btoa(userName + ":" + password),
    },
  }
).then((response) => console.log(response),(error) => console.log(error));

Cada vez que se produce una petición con autentificación básica (petición de login y las que van con usuario y contraseña) se ejecuta la siguiente clase.

En el acaso de que en la base de datos exista un usuario con el el nombre de usuario que recibimos como parámetro se devuelve una instancia del mismo a partir de la cual SpringSecurity hará automáticamente una validación de la contraseña.

package com.pablomonteserin.basicauthentification.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import com.pablomonteserin.basicauthentification.model.User;
import com.pablomonteserin.basicauthentification.repository.UserRepository;

@Service
public class CustomUserDetailsService implements UserDetailsService {

 @Autowired
 private UserRepository userRepository;
 
 @Override
 public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  User user = userRepository.findByUserName(username);
  if (null == user) {
   throw new UsernameNotFoundException("Ususario no encontrado "+username);
  }  
  return user;
 }
}

Si la autentificación anterior es correcta, llegaremos al método del controlador, que en este caso va a devolver el nombre del usuario logueado:

package com.pablomonteserin.basicauthentification.controller;

import java.security.Principal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import com.pablomonteserin.basicauthentification.model.User;

@RestController
public class BasicAuthController {

 @PostMapping(path = "/login")
 public String basicauth(Principal principal) {
  // El objeto principal tiene información sobre el usuario y la contraseña, aunque de todas formas no la vamos a utilizar
  // No devolveremos el usuario ni la contraseña al front, sino información sobre si el login ha sido exitoso. Si lo ha sido, a partir de ese momento, desde el front, mandaremos en la cabecera de cada petición el username y password que han provocado que el login sea exitoso

  return ResponseEntity.ok().body("{\"resp\":\"Login exitoso\"}");

 }
}

Configuración del entorno

Dependencias

El paquete base del proyecto que vamos a crear será com.pablomonteserin.basicauthentification.

Añadimos las dependencias de Spring Security al pom.xml.

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Configuración del contexto de seguridad de Spring

com.pablomonteserin.withspringsecurity.config.SecurityConfig.java

package com.pablomonteserin.basicauthentification.config;

import static org.springframework.security.config.Customizer.withDefaults;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@EnableWebSecurity
@Configuration
public class SecurityConfig {

 @Value("${app.local-domain-front}")
 private String localDomainFront;

 @Autowired
 private UserDetailsService userDetailsService;

 @Autowired
 private BCryptPasswordEncoder bCryptPasswordEncoder;

 public AuthenticationSuccessHandler succesHandler() {
  return (request, response, authentication) -> response.sendRedirect("/");

 }

 @Autowired
 public void configAuthentication(AuthenticationManagerBuilder auth) throws Exception {
  auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder);
 }

 @Bean
 AuthenticationManager authenticationManager(HttpSecurity http, BCryptPasswordEncoder bCryptPasswordEncoder)
   throws Exception {
  AuthenticationManagerBuilder authenticationManager = http.getSharedObject(AuthenticationManagerBuilder.class);
  authenticationManager.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder);
  return authenticationManager.build();
 }

 @Bean
 SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
  http.csrf(csrf -> csrf.disable()); // Deshabilitamos la protección contra ataques Cross-site request forgery
      // para evitar su configuración en la cabecera de la peticción
  // Definimos que urls serán públicas
  http.authorizeHttpRequests((requests) -> {
   try {
    requests.requestMatchers("/login", "/login?logout", "/logout").permitAll().anyRequest().authenticated();
   } catch (Exception e) {
    e.printStackTrace();
   }
  }).httpBasic(withDefaults());
  return http.build();
 }

 // Configuración del CORS (Cross-origin resource sharing)
 @Bean
 WebMvcConfigurer corsConfigurer() {
  return new WebMvcConfigurer() {
   @Override
   public void addCorsMappings(CorsRegistry registry) {
    registry.addMapping("/**").allowedOrigins(localDomainFront);
    registry.addMapping("/**").allowedMethods("POST", "PUT", "GET", "DELETE", "OPTIONS");
   }
  };
 }
}

La clase anterior usa esta clase para encriptar los datos:

com.pablomonteserin.withspringsecurity.config.Encoder.java

package com.pablomonteserin.basicauthentification.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
public class Encoder {

 @Bean(name = "passwordEncoder")
 BCryptPasswordEncoder passwordencoder() {
  return new BCryptPasswordEncoder();
 }
}

Configuración del modelo de usuario

La clase User tendría que tener como mínimo usuario y contraseña. Sin embargo, cuando usamos Spring Security, la recomendación es que además la base de datos tenga las propiedades indicadas por la interfaz de UserDetails.

Para que el login funcione correctamente, en la base de datos, tendríamos que establecer con valor true las propiedades accountNonExpired, accountNonLocked, credentialsNonExpired, enabled.

com.pablomonteserin.basicauthentification.model.User.java

package com.pablomonteserin.basicauthentification.model;

import java.util.ArrayList;
import java.util.Collection;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
@Entity
@Table(name = "user")
public class User implements UserDetails {
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY) // Para generar números autoincrementados
 private int id;
 private String userName;
 private String password;
 private boolean accountNonExpired;
 private boolean accountNonLocked;
 private boolean credentialsNonExpired;
 private boolean enabled;

 @Override
 public Collection<? extends GrantedAuthority> getAuthorities() {
  // Devolvemos un ArrayList vacío porque nuestra app no tiene roles
  return new ArrayList<>();
 }

 @Override
 public boolean isAccountNonExpired() {
  return accountNonExpired;
 }

 @Override
 public boolean isAccountNonLocked() {
  return accountNonLocked;
 }

 @Override
 public boolean isCredentialsNonExpired() {
  return credentialsNonExpired;
 }

 @Override
 public boolean isEnabled() {
  return enabled;
 }

 @Override
 public String getUsername() {
  return userName;
 }

 @Override
 public String getPassword() {
  return password;
 }
}

Probando el acceso

Para probar el acceso con Postman a una url que requiera autentificación, usaremos la siguiente configuración:

Recuerda que debemos tener protegida la url de acceso y para ello debe estar en el siguiente listado:

@Bean
SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
 http.csrf(csrf -> csrf.disable()); // Deshabilitamos la protección contra ataques Cross-site request forgery
 http.authorizeHttpRequests((requests) -> {
 try {
  requests.requestMatchers("/evento/","/evento","/user/","/user", "/logout").permitAll().anyRequest().authenticated();
  ...
}

Ten en cuenta que para que el acceso esté habilitado, los campos account_non_expired, account_not_locked, credentials_non_expired, enabled deben valer 1.

INSERT INTO usuario_eventos.user (id, about_you, account_non_expired, account_non_locked, credentials_non_expired, enabled, password, user_name) VALUES ('1', 'hola', 1, 1, 1, '23', 1, 'paco', '$2a$10$US2YnaQEPd3geX5s.SsjfOGTwPN8qwSHa1NhiQ82.qJ1Ed1HYPtAi') // la contraseña es hola

Probando el registro

Para que un nuevo usuario se registre, es necesario encriptar su contraseña para almacenarla en la base de datos. Para ello, usaremos un código similar a este:

@AutoWired
BCryptPasswordEncoder encoder;
...
encoder.encode("password ");

Ten en cuenta que si las propiedades del objeto usuario que enviamos para guardar en la base de datos no coinciden con el objeto Usario que tenemos como parámetro de entrada de la función de registro, nos dará un error 401 (acceso no autorizado), a pesar de que el problema es que los datos mandados no coinciden y no que la url esté protegida.

Para evitar el problema anterior, podemos usar las clases DTO, que son clases con propiedades análogas a las del modelo (UserDTO es análoga a User) pero que tienen únicamente las propiedades que vamos a enviar o recibir del front.

Luego para mapear las propiedades del DTO a una Entity usaremos los siguientes servicios:

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;
    
    @Autowired
 BCryptPasswordEncoder encoder;

    public User saveUser(UserDTO userDTO) {
        User user = new User();
        user.setName(userDTO.getName());
        user.setSurname(userDTO.getSurname());
        user.setUsername(userDTO.getUsername());
        String encryptedPassword = encoder.encode(userDTO.getPassword());
  user.setPassword(encryptedPassword);
        user.setEmail(userDTO.getEmail());
        return userRepository.save(user);
    }
}