Comment recharger les autorités de l'utilisateur mise à jour avec Ressort de Sécurité

Merci, beaucoup m'aider ! Avec SessionRegistry, je peux utiliser getAllPrincipals() à comparer à l'utilisateur de modifier avec le courant d'utilisateurs actifs dans les sessions. Si une session existe pas, je peut invalider sa session à l'aide de : expireNow() (à partir de SessionInformation) à force de ré-authentification.

Mais je ne comprends pas l'utilité de securityContextPersistenceFilter ?

EDIT :

//user object = User currently updated
//invalidate user session
List<Object> loggedUsers = sessionRegistry.getAllPrincipals();
for (Object principal : loggedUsers) {
    if(principal instanceof User) {
        final User loggedUser = (User) principal;
        if(user.getUsername().equals(loggedUser.getUsername())) {
            List<SessionInformation> sessionsInfo = sessionRegistry.getAllSessions(principal, false);
            if(null != sessionsInfo && sessionsInfo.size() > 0) {
                for (SessionInformation sessionInformation : sessionsInfo) {
                    LOGGER.info("Exprire now :" + sessionInformation.getSessionId());
                    sessionInformation.expireNow();
                    sessionRegistry.removeSessionInformation(sessionInformation.getSessionId());
                    //User is not forced to re-logging
                }
            }
        }
    }
} 

Si quelqu'un est toujours à la recherche dans la façon de mettre à jour les autorités d'un autre utilisateur sans forcer l'utilisateur à se ré-authentifier, vous pouvez essayer d'ajouter un intercepteur qui recharge l'authentification. Ce sera assurez-vous que vos autorités sont toujours à jour.

Cependant, pour des raisons extra, intercepteur, il y aura un certain impact sur les performances (par exemple, si vous obtenez vos rôles d'utilisateur de votre base de données, il va être interrogé pour chaque requête HTTP).

@Component
public class VerifyAccessInterceptor implements HandlerInterceptor {

    //...

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        Set<GrantedAuthority> authorities = new HashSet<>();
        if (auth.isAuthenticated()) {
            authorities.add(new SimpleGrantedAuthority("ROLE_USER"));
        }

        User userFromDatabase = getUserFromDatabase(auth.getName());
        if (userFromDatabase != null) {
            //add whatever authorities you want here
            authorities.add(new SimpleGrantedAuthority("...")); 
        }

        Authentication newAuth = null;

        if (auth.getClass() == OAuth2AuthenticationToken.class) {
            OAuth2User principal = ((OAuth2AuthenticationToken)auth).getPrincipal();
            if (principal != null) {
                newAuth = new OAuth2AuthenticationToken(principal, authorities,(((OAuth2AuthenticationToken)auth).getAuthorizedClientRegistrationId()));
            }
        }

        SecurityContextHolder.getContext().setAuthentication(newAuth);
        return true;
    }

}

Cette implémentation utilise OAuth2 (OAuth2AuthenticationToken), mais vous pouvez utiliser UsernamePasswordAuthenticationToken à la place.

Et maintenant, pour ajouter votre intercepteur de configuration:

@Configuration
public class WebConfiguration extends WebMvcConfigurationSupport {

    @Autowired
    private VerifyAccessInterceptor verifyAccessInterceptor;


    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(verifyAccessInterceptor).addPathPatterns("/**");
    }

}

J'ai aussi fait un article à ce sujet.

J'ai un cas très spécifique de ci-dessus, j'utilise Redis pour suivre la session de l'utilisateur avec https://github.com/spring-projects/spring-session. Alors quand l'admin ajoute un certain Rôle à l'utilisateur, je trouve session de l'utilisateur dans le Redis et le remplacer principal et authorities puis enregistrer la session.

public void updateUserRoles(String username, Set<GrantedAuthority> newRoles) {
if (sessionRepository instanceof FindByIndexNameSessionRepository) {
Map<String, org.springframework.session.Session> map =
((FindByIndexNameSessionRepository<org.springframework.session.Session>) sessionRepository)
.findByPrincipalName(username);
for (org.springframework.session.Session session : map.values()) {
if (!session.isExpired()) {
SecurityContext securityContext = session.getAttribute(SPRING_SECURITY_CONTEXT_KEY);
Authentication authentication = securityContext.getAuthentication();
if (authentication instanceof UsernamePasswordAuthenticationToken) {
Collection<GrantedAuthority> authorities = new HashSet<>(authentication.getAuthorities());
//1. Update of authorities
authorities.addAll(newRoles);
Object principalToUpdate = authentication.getPrincipal();
if (principalToUpdate instanceof User) {
//2. Update of principal: Your User probably extends UserDetails so call here method that update roles to allow
//org.springframework.security.core.userdetails.UserDetails.getAuthorities return updated 
//Set of GrantedAuthority
securityContext
.setAuthentication(new UsernamePasswordAuthenticationToken(principalToUpdate, authentication
.getCredentials(), authorities));
session.setAttribute(SPRING_SECURITY_CONTEXT_KEY, securityContext);
sessionRepository.save(session);
}
}
}
}
}
}