Curso de Spring Boot | 3. 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.

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

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

Flujo de una petición de autentificación

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

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 caso 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.app.services;
...
@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.app.controllers;

@RestController
public class BasicAuthController {

	@PostMapping(path = "/login")
	public ResponseEntity<String> basicauth(UsernamePasswordAuthenticationToken upa) {
		// El objeto upa tiene información sobre el usuario y la contraseña
		// Si el login ha sido exitoso, 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
		User u = (User) upa.getPrincipal(); // Si en IntelliJ nos da un error cannot find symbol, significa que no esta pillando el getter de la id		
		return ResponseEntity.ok().body("{\"resp\":\"Login exitoso\", \"id\":"+u.getId()+"}");

	}
}

Configuración del entorno

Configuración del contexto de seguridad de Spring

package com.app.config;

// Springboot inspecciona todas las clases anotadas con @Configuration, @Component, @Service, @Repository y @Controller en busca de anotaciones de Springboot dentro de la propia clase
@Configuration
public class Encoder {
        // Creamos un bean de la clase BCryptPasswordEncoder para tenerlo disponible en el contexto, y poder materializar el Autowired de la clase SecurityConfig
	@Bean(name = "passwordEncoder")
	BCryptPasswordEncoder passwordencoder() {
		return new BCryptPasswordEncoder();
	}
}

package com.app.config;

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

@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
		.cors(withDefaults())
		.authorizeHttpRequests((requests) -> {
			try {							    
				// Definimos que urls estarán desprotegidas y no necesitarán recibir las credenciales para poder ser accedidas
				requests.requestMatchers("/endpointdesprotegido").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");
			}
		};
	}
}

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.

package com.app.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;
	}
}

application.properties

...
app.local-domain-front=http://localhost:5173

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));

Ejercicio – Login y acceso a un endpoint restringido

Código del front:

api.js

export const login = async (username, password) => {
    const token = btoa(username + ":" + password);
    const response = await i.post("/login",{},
    {
        headers: {
            "Content-Type": "application/json",
            Authorization: "basic " + token,
        },
    });
    if(response.resp === "ok"){
        setAuth(token);
    }
}


export const setAuth = async (token) => {
    i.defaults.headers.common.Authorization = `basic ${token}`;
};

export const test = () => {
	i.get("/users");
}

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

Mensajería

Al generar el JSON, las relaciones oneToMany pueden ser problemáticas, si queremos que no aparezcan en el JSON, podemos utilizar este código en la entidad:

@JsonIgnoreProperties({"mensajesEnviados","mensajesRecibidos"})
public class Usuario{

@Entity
public class User{
	...
	//Siempre que tengamos una relación OneToMany, usaremos el mappedBy
	@OneToMany(mappedBy = "remitente")
	private List <Mensaje> mensajesEnviados;
	@OneToMany(mappedBy = "destinatario")
	private List <Mensaje> mensajesRecibidos;

@Entity
public class Mensaje {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)//Para generar números autoincrementados
	private int id;
	@ManyToOne
	private User remitente;
	@ManyToOne
	private User destinatario;
	private String mensaje;

hilo
id	id_usuario	nombre_hilo	texto_hilo
7	1	Escoger ordenador	Dónde comprar uno bueno
8	1	¿Qué opinas de Ubuntu?	Dudas sobre Ubuntu

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, que utilizan las siguientes dependencias que habría que añadir al pon.xml.

<dependency>
	<groupId>org.mapstruct</groupId>
	<artifactId>mapstruct</artifactId>
	<version>1.5.3.Final</version>
</dependency>
<dependency>
	<groupId>org.mapstruct</groupId>
	<artifactId>mapstruct-processor</artifactId>
	<version>1.5.3.Final</version>
	<scope>provided</scope>
</dependency>

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;
    
    @Autowired
	BCryptPasswordEncoder encoder;

    public User saveUser(UserDTO userDTO) {
        User user = fromUserDTO(userDTO);
        String encryptedPassword = encoder.encode(userDTO.getPassword());
	user.setPassword(encryptedPassword);
        user.setEmail(userDTO.getEmail());
        return userRepository.save(user);
    }
}

@Service
public class PasswordEncoderService {
    private final PasswordEncoder passwordEncoder;

    public PasswordEncoderService(PasswordEncoder passwordEncoder) {
        this.passwordEncoder = passwordEncoder;
    }

    public String encodePassword(String rawPassword) {
        return passwordEncoder.encode(rawPassword);
    }
}