Autentificación por medio de las cookies en la primavera de arranque

mounika:

// Parte de mi clase Controller

@RequestMapping("/login")
    public String login(HttpServletRequest request,HttpServletResponse response) {
        request.setAttribute("mode", "MODE_LOGIN");


        return "welcomepage";
    }

    @RequestMapping ("/login-user")
    public String loginUser(@ModelAttribute User user, HttpServletRequest request,HttpServletResponse response) {
        if((userService.findByUsernameAndPassword(user.getUsername(), user.getPassword())!=null)) {
            Cookie loginCookie=new Cookie("mouni","user.getUsername()");
            loginCookie.setMaxAge(30*5);
            response.addCookie(loginCookie);
        return "homepage";
        }
        else {
            request.setAttribute("error", "Invalid Username or Password");
            request.setAttribute("mode", "MODE_LOGIN");
            return "welcomepage";

        }

    }

Estoy haciendo un proyecto de gestión de la biblioteca en el arranque de primavera java. Tengo un problema, me gustaría hacer uso de cookies de autenticación. En resumen, una vez después de usuario conectado con sus credenciales, nombre de usuario debe ser guardado como valor de la cookie. La próxima vez que el usuario va a inicio de sesión, puede simplemente introducir nombre de usuario y debe estar conectado correctamente. Podría alguien ayudarme

g00glen00b:

Dado que la seguridad es un asunto complejo, recomiendo el uso de la primavera de Seguridad , a pesar de que está encargado de hacerlo sin. Para ilustrar la complejidad por la seguridad, ya puedo decirle que su código actual tiene una vulnerabilidad , ya que usted está confiando en un nombre de usuario contraseña en texto plano como su única autenticación. La primavera de Seguridad por el contrario utiliza una clave para generar un recuerdo me cookie para que sea mucho más difícil de suplantar a alguien (a menos que conozca la clave).

Por lo tanto, si usted estaría utilizando Spring Security, la primera cosa que hay que hacer es crear una UserDetailsService, que tiene un método llamado loadByUsername(). Para llevar a cabo esto, se podía usar su UserServicey utilizar el Userconstructor para construir un objeto de usuario de Seguridad de primavera:

public class MyUserDetailsService implements UserDetailsService {
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        if ("admin".equalsIgnoreCase(username)) {
        return User.builder()
            .username(username)
            // This should contain the hashed password for the requested user
            .password("$2a$10$T5viXrOTIkraRe2mZPyZH.MAqKaR6x38L.rbmRp53yQ8R/cFrJkda")
            // If you don't need roles, just provide a default one, eg. "USER"
            .roles("USER", "ADMIN")
            .build();
    } else {
        // Throw this exception if the user was not found
        throw new UsernameNotFoundException("User not found");
    }
}

Tenga en cuenta, al contrario que en el original UserService.findByUsernameAndPassword()que usted no tiene que comprobar la contraseña por sí mismo, simplemente recuperar el objeto de usuario y contraseña de pasar el hash.

El siguiente paso es proporcionar una adecuada PasswordEncoderfrijol. En mi ejemplo estoy usando Bcrypt con 10 rotaciones, así que creé el siguiente frijol:

@EnableWebSecurity
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

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

    @Bean
    public UserDetailsService userDetailsService() {
        return new MyUserDetailsService();
    }
}

El siguiente paso es configurar la primavera de Seguridad. Por ejemplo:

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .antMatcher("/**")
        .authorizeRequests()
            .anyRequest().authenticated()
            .and()
        .formLogin()
            .loginPage("/login.html").permitAll()
            .loginProcessingUrl("/login-user").permitAll().usernameParameter("username").passwordParameter("password")
            .defaultSuccessUrl("/welcome.html")
            .and()
        .rememberMe()
            .alwaysRemember(true)
            .tokenValiditySeconds(30*5)
            .rememberMeCookieName("mouni")
            .key("somesecret")
            .and()
        .csrf().disable();
}

En este caso, todos los puntos finales ( /**serán aseguradas), tendrá un formulario de acceso al login.htmlque contiene dos campos de formulario ( usernamee password). El destino de la forma debe ser /login-usery cuando un usuario se registra con éxito en, será redirigido a /welcome.html.

De manera similar a lo que ha escrito en su código, esto generará una cookie llamada mounique contiene un valor (ya no es un nombre de usuario natural) y que será válida durante 150 segundos, al igual que en su ejemplo.

Estoy desactivando CSRF aquí porque estoy usando un simple formulario HTML, y de otra manera tendría que añadir un motor de plantillas para pasar la llave CSRF. Idealmente, usted debe tener esto activado.