java - taglibs - spring security xml

Agregar detalles adicionales al objeto principal almacenado en el contexto de seguridad de Spring

Question

Estoy usando Spring 3.0 y Spring Security 3. Puedo autenticar a un usuario en una base de datos usando Spring Security. Utilizando:

SecurityContextHolder.getContext().getAuthentication().getPrincipal()

Soy capaz de recuperar el nombre de usuario del usuario registrado actual. Deseo agregar detalles adicionales como la identificación del usuario y los accesos del módulo al objeto principal almacenado en el contexto de Spring Security para poder recuperarlo más adelante. ¿Cómo puedo agregar detalles adicionales al objeto principal y luego cómo puedo recuperarlo más adelante en una clase jsp o java? Por favor, proporcione un fragmento de código apropiado si es posible.

Editar: Estoy usando JDBC para acceder a mi base de datos.

Gracias por adelantado.

Answer 1

(Asumiré que tiene una configuración básica de Spring Security funcionando y sabe cómo funcionan juntos los componentes básicos)

La forma más "correcta" sería proporcionar su propia implementación de AuthenticationProvider , que devuelva una implementación de Authentication personalizada. Luego, puede completar esta instancia de Authentication con todo lo que necesita. Por ejemplo:

public class MyAuthentication extends UsernamePasswordAuthenticationToken implements Authentication {

    public MyAuthentication(Object principal, Object credentials, int moduleCode) {
        super(principal, credentials);
        this.moduleCode = moduleCode;
    }

    public MyAuthentication(Object principal, Object credentials,  Collection<? extends GrantedAuthority> authorities,int moduleCode) {
        super(principal, credentials, authorities);
        this.moduleCode = moduleCode;
    }

    private int moduleCode;

    public getModuleCode() {
        return moduleCode;
    }   
}


public class MyAuthenticationProvider extends DaoAuthenticationProvider {

    private Collection<GrantedAuthority> obtainAuthorities(UserDetails user) {
        // return granted authorities for user, according to your requirements
    }

    private int obtainModuleCode(UserDetails user) {
        // return moduleCode for user, according to your requirements
    }

    @Override
    public Authentication createSuccessAuthentication(Object principal, Authentication authentication, UserDetails user) {
        // Suppose this user implementation has a moduleCode property
        MyAuthentication result = new MyAuthentication(authentication.getPrincipal(),
                                                       authentication.getCredentials(),
                                                       obtainAuthorities(user),
                                                       obtainModuleCode(user));
        result.setDetails(authentication.getDetails());
        return result;
    }
}

Y luego, en applicationContext.xml :

<authentication-manager>
    <authentication-provider ref="myAuthenticationProvider">
</authentication-manager>

<bean id="myAuthenticationProvider" class="MyAuthenticationProvider" scope="singleton">
    ...
</bean>

Supongo que podría hacerlo funcionar al proporcionar implementaciones personalizadas de AuthenticationDetails y AuthenticationDetailsSource , pero creo que sería un enfoque menos claro.

Answer 2

Esto es lo que necesita:

1. Extienda la clase Spring User ( org.springframework.security.core.userdetails.User ) y las propiedades que necesite.
2. Extienda Spring UserDetailsService ( org.springframework.security.core.userdetails.UserDetailsService ) y complete el objeto anterior. Sobrescriba loadUserByUsername y devuelva su clase de usuario extendida
3. Configure su UserDetailsService personalizado en AuthenticationManagerBuilder

Por ejemplo

public class CurrentUser extends User{

   //This constructor is a must
    public CurrentUser(String username, String password, boolean enabled, boolean accountNonExpired,
            boolean credentialsNonExpired, boolean accountNonLocked,
            Collection<? extends GrantedAuthority> authorities) {
        super(username, password, enabled, accountNonExpired, credentialsNonExpired, accountNonLocked, authorities);
    }
    //Setter and getters are required
    private String firstName;
    private String lastName;

}

Los detalles personalizados del usuario podrían ser:

@Service("userDetailsService")
public class CustomUserDetailsService implements UserDetailsService {

@Override
public UserDetails loadUserByUsername(final String username) throws UsernameNotFoundException {

    //Try to find user and its roles, for example here we try to get it from database via a DAO object
   //Do not confuse this foo.bar.User with CurrentUser or spring User, this is a temporary object which holds user info stored in database
    foo.bar.User user = userDao.findByUserName(username);

    //Build user Authority. some how a convert from your custom roles which are in database to spring GrantedAuthority
    List<GrantedAuthority> authorities = buildUserAuthority(user.getUserRole());

    //The magic is happen in this private method !
    return buildUserForAuthentication(user, authorities);

}


//Fill your extended User object (CurrentUser) here and return it
private User buildUserForAuthentication(foo.bar.User user, 
List<GrantedAuthority> authorities) {
    String username = user.getUsername();
    String password = user.getPassword();
    boolean enabled = true;
    boolean accountNonExpired = true;
    boolean credentialsNonExpired = true;
    boolean accountNonLocked = true;

    return new CurrentUser(username, password, enabled, accountNonExpired, credentialsNonExpired,
            accountNonLocked, authorities);
   //If your database has more information of user for example firstname,... You can fill it here 
  //CurrentUser currentUser = new CurrentUser(....)
  //currentUser.setFirstName( user.getfirstName() );
  //.....
  //return currentUser ;
}

private List<GrantedAuthority> buildUserAuthority(Set<UserRole> userRoles) {

    Set<GrantedAuthority> setAuths = new HashSet<GrantedAuthority>();

    // Build user''s authorities
    for (UserRole userRole : userRoles) {
        setAuths.add(new SimpleGrantedAuthority(userRole.getRole()));
    }

    return new ArrayList<GrantedAuthority>(setAuths);
}

}

Configurar el contexto de seguridad de primavera.

@Configuration
@EnableWebSecurity
@PropertySource("classpath://configs.properties")
public class SecurityContextConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    @Qualifier("userDetailsService")
    private UserDetailsService userDetailsService;

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }

¡Está todo hecho!

Puede llamar a (CurrentUser)getAuthentication().getPrincipal() para obtener un CurrentUser nuevo o establecer algunas propiedades.

Answer 3

Lo "único" que debe hacer es crear su propia implementación UserDetailsService que devuelva su propia implementación de un objeto UserDetailsService .

Consulte here un tutorial que implementa un UserDetailsService basado en JPA.

Answer 4

Para agregar más detalles al usuario autenticado. Primero debe crear su propia implementación del objeto Usuario, que debe extender el objeto Usuario de seguridad Spring. Después de eso, puede agregar las propiedades que desea agregar al usuario autenticado. Una vez hecho esto, debe devolver su implementación del objeto de usuario en UserDetailService (si no está usando LDAP para la autenticación). Este enlace proporciona los detalles para agregar más detalles al usuario autenticado:

http://javahotpot.blogspot.in/2013/12/spring-security-adding-more-information.html