Ejemplo Spring: ejemplo básico de autenticación

Primero tendremos que tener un área que queramos restringir, por ejemplo esta... con información muy confidencial:

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class RestrictedController
{
    @GetMapping ("/restricted")
    @ResponseBody
    public String accessToRestricted()
    {
        return "Hola hola mundo!";
    }
}

Si no hay nada que restringir no tiene sentido todo esto la verdad. Después, en nuestro pom.xml, (en mi caso uso Maven... buff), deberíamos incluir la siguiente dependencia:

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

Con esa dependencia integramos este framework de seguridad de Spring de forma muy sencilla. Luego deberíamos incluir la configuración de seguridad, a través de una clase:

• Clase con anotación @Configuration para indicar que es de configuración.
• Anotación @EnableWebSecurity para habilitar la configuración de seguridad.
• Extendemos el adaptador WebSecurityConfigurerAdapter que tiene métodos configure para configurar la seguridad.
  
• Sobrescribimos el método configure (HttpSecurity httpsec) con las restricciones que deseamos.
• Creamos un método en el que inyectamos AuthenticationManagerBuilder auth, con @Autowired, para crear una configuración básica de usuario.

Veamos:

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
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.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter
{ 

    private final Log logger = LogFactory.getLog(SecurityConfig.class);

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    protected void configure(HttpSecurity httpsec) throws Exception{
        httpsec.authorizeRequests()
                .antMatchers("/").permitAll()
                .anyRequest().authenticated()
            .and()
                .formLogin().permitAll();   
    }

    @Autowired
    protected void confDatosAccesoUsuarios (AuthenticationManagerBuilder auth) {
        try {
            auth.inMemoryAuthentication()
            .withUser("test").password(passwordEncoder.encode("test")).roles("USER");
        } catch (Exception e)
        {
            logger.error(e.toString());
        }
    }

}

Dentro del método configure, se emplea la instancia httpsec para indicar la configuración de seguridad... un poco extraño al principio la verdad.

De momento le estamos diciendo que solo permita acceder a la página raíz (.antMatchers("/").permitAll()) y al resto no (.anyRequest().authenticated()). Después, que habrá un formulario de login al que tendrá todo el mundo acceso (.formLogin().permitAll()). Como no hemos indicado ninguno propio, este framework de Spring Security proveerá uno por defecto, algo así:

Y falta una cosa, la parte del PasswordEncoder que está @Autowired en la configuración anterior. Esto es un @Bean que debemos poner en algún lado (que tenga @Configuration o que lo incluya, como es el caso de @SpringBootApplication). Por ejemplo, en la clase principal de nuestra aplicación Spring Boot:

@SpringBootApplication
public class Application {

  ...

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

  ...
}

Así todas nuestras contraseñas estarán codificadas en memoria y no en texto plano, dado que ese bean proveerá el mecanismo para ello.

Y esto es todo... poca cosa.