Comment vérifier «hasRole» dans Java Code avec Spring Security?

Comment vérifier les droits ou autorisations des utilisateurs dans Java Code? Par exemple - Je veux afficher ou masquer le bouton pour l'utilisateur en fonction du rôle. Il y a des annotations comme:

@PreAuthorize("hasRole('ROLE_USER')")

Comment le faire en code Java? Quelque chose comme :

if(somethingHere.hasRole("ROLE_MANAGER")) {
   layout.addComponent(new Button("Edit users"));
}

Spring Security 3.0 a cette API

SecurityContextHolderAwareRequestWrapper.isUserInRole(String role)

Vous devrez injecter le wrapper avant de l'utiliser.

SecurityContextHolderAwareRequestWrapper

vous pouvez utiliser la méthode isUserInRole de l'objet HttpServletRequest.

quelque chose comme:

public String createForm(HttpSession session, HttpServletRequest request,  ModelMap   modelMap) {


    if (request.isUserInRole("ROLE_ADMIN")) {
        // code here
    }
}

Au lieu d'utiliser une boucle pour trouver l'autorité à partir de UserDetails, vous pouvez faire:

Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
boolean authorized = authorities.contains(new SimpleGrantedAuthority("ROLE_ADMIN"));

Vous pouvez récupérer le contexte de sécurité, puis l'utiliser:

    import org.springframework.security.core.Authentication;
    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.core.context.SecurityContext;
    import org.springframework.security.core.context.SecurityContextHolder;

    protected boolean hasRole(String role) {
        // get security context from thread local
        SecurityContext context = SecurityContextHolder.getContext();
        if (context == null)
            return false;

        Authentication authentication = context.getAuthentication();
        if (authentication == null)
            return false;

        for (GrantedAuthority auth : authentication.getAuthorities()) {
            if (role.equals(auth.getAuthority()))
                return true;
        }

        return false;
    }

Vous pouvez implémenter une méthode hasRole () comme ci-dessous - (Ceci est testé sur Spring Security 3.0.x pas sûr des autres versions.)

  protected final boolean hasRole(String role) {
    boolean hasRole = false;
    UserDetails userDetails = getUserDetails();
    if (userDetails != null) {
      Collection<GrantedAuthority> authorities = userDetails.getAuthorities();
      if (isRolePresent(authorities, role)) {
        hasRole = true;
      }
    } 
    return hasRole;
  }
  /**
   * Get info about currently logged in user
   * @return UserDetails if found in the context, null otherwise
   */
  protected UserDetails getUserDetails() {
    Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    UserDetails userDetails = null;
    if (principal instanceof UserDetails) {
      userDetails = (UserDetails) principal;
    }
    return userDetails;
  }
  /**
   * Check if a role is present in the authorities of current user
   * @param authorities all authorities assigned to current user
   * @param role required authority
   * @return true if role is present in list of authorities assigned to current user, false otherwise
   */
  private boolean isRolePresent(Collection<GrantedAuthority> authorities, String role) {
    boolean isRolePresent = false;
    for (GrantedAuthority grantedAuthority : authorities) {
      isRolePresent = grantedAuthority.getAuthority().equals(role);
      if (isRolePresent) break;
    }
    return isRolePresent;
  }

J'utilise ceci:

@RequestMapping(method = RequestMethod.GET)
public void welcome(SecurityContextHolderAwareRequestWrapper request) {
    boolean b = request.isUserInRole("ROLE_ADMIN");
    System.out.println("ROLE_ADMIN=" + b);

    boolean c = request.isUserInRole("ROLE_USER");
    System.out.println("ROLE_USER=" + c);
}

Vous pouvez obtenir de l'aide de la classe AuthorityUtils . Vérification du rôle en tant que one-liner:

if (AuthorityUtils.authorityListToSet(SecurityContextHolder.getContext().getAuthentication().getAuthorities()).contains("ROLE_MANAGER")) {
    /* ... */
}

Attention: cela ne vérifie pas la hiérarchie des rôles, si elle existe.

La réponse de JoseK ne peut pas être utilisée lorsque vous êtes dans votre couche de service, où vous ne voulez pas introduire de couplage avec la couche Web de la référence à la requête HTTP. Si vous envisagez de résoudre les rôles dans la couche de service, la réponse de Gopi est la voie à suivre.

Cependant, c'est un peu long. Les autorités sont accessibles directement à partir de l'authentification. Par conséquent, si vous pouvez supposer que vous avez un utilisateur connecté, ce qui suit le fait:

/**
 * @return true if the user has one of the specified roles.
 */
protected boolean hasRole(String[] roles) {
    boolean result = false;
    for (GrantedAuthority authority : SecurityContextHolder.getContext().getAuthentication().getAuthorities()) {
        String userRole = authority.getAuthority();
        for (String role : roles) {
            if (role.equals(userRole)) {
                result = true;
                break;
            }
        }

        if (result) {
            break;
        }
    }

    return result;
}

La plupart des réponses manquent certains points:

1. Le rôle et l'autorité ne sont pas la même chose au printemps. Voir ici pour plus de détails.

2. Les noms de rôle sont égaux à rolePrefix+ authority.

3. Le préfixe de rôle par défaut est ROLE_cependant configurable. Regardez ici .

Par conséquent, une vérification de rôle appropriée doit respecter le préfixe de rôle s'il est configuré.

Malheureusement, la personnalisation du préfixe de rôle dans Spring est un peu piratée, dans de nombreux endroits, le préfixe par défaut ROLE_est codé en dur, mais en plus de cela, un bean de type GrantedAuthorityDefaultsest vérifié dans le contexte Spring, et s'il existe, le préfixe de rôle personnalisé il a est respecté.

En rassemblant toutes ces informations, une meilleure implémentation du vérificateur de rôle serait quelque chose comme:

@Component
public class RoleChecker {

    @Autowired(required = false)
    private GrantedAuthorityDefaults grantedAuthorityDefaults;

    public boolean hasRole(String role) {
        String rolePrefix = grantedAuthorityDefaults != null ? grantedAuthorityDefaults.getRolePrefix() : "ROLE_";
        return Optional.ofNullable(SecurityContextHolder.getContext().getAuthentication())
                .map(Authentication::getAuthorities)
                .map(Collection::stream)
                .orElse(Stream.empty())
                .map(GrantedAuthority::getAuthority)
                .map(authority -> rolePrefix + authority)
                .anyMatch(role::equals);
    }
}

Curieusement, je ne pense pas qu'il existe une solution standard à ce problème, car le contrôle d'accès de sécurité par ressort est basé sur l'expression et non sur Java. vous pouvez vérifier le code source de DefaultMethodSecurityExpressionHandler pour voir si vous pouvez réutiliser quelque chose qu'ils font là-bas

Mieux vaut tard que jamais, laissez-moi mettre ma valeur de 2 cents.

Dans le monde JSF, dans mon bean géré, j'ai fait ce qui suit:

HttpServletRequest req = (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest();
SecurityContextHolderAwareRequestWrapper sc = new SecurityContextHolderAwareRequestWrapper(req, "");

Comme mentionné ci-dessus, je crois comprendre que cela peut être fait de la manière suivante:

Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
UserDetails userDetails = null;
if (principal instanceof UserDetails) {
    userDetails = (UserDetails) principal;
    Collection  authorities = userDetails.getAuthorities();
}

Cela vient en quelque sorte de la question de l'autre côté, mais j'ai pensé que je la jetterais car je devais vraiment fouiller sur Internet pour le savoir.

Il y a beaucoup de choses sur la façon de vérifier les rôles, mais pas beaucoup de dire ce que vous vérifiez réellement quand vous dites hasRole ("bla")

HasRole vérifie les autorités accordées pour le principal actuellement authentifié

Donc vraiment quand vous voyez hasRole ("blah") signifie vraiment hasAuthority ("blah") .

Dans le cas que j'ai vu, vous faites cela avec une classe qui implémente UserDetails qui définit une méthode appelée getAuthorities. En cela, vous en ajouterez essentiellement new SimpleGrantedAuthority("some name")à une liste basée sur une logique. Les noms de cette liste sont les éléments vérifiés par les instructions hasRole.

Je suppose que dans ce contexte, l'objet UserDetails est le principal actuellement authentifié. Il y a de la magie qui se produit dans et autour des fournisseurs d'authentification et plus particulièrement dans le gestionnaire d'authentification qui rend cela possible.

La réponse @gouki est la meilleure!

Juste un conseil sur la façon dont le printemps fait vraiment cela.

Il existe une classe nommée SecurityContextHolderAwareRequestWrapperqui implémente la ServletRequestWrapperclasse.

Le SecurityContextHolderAwareRequestWrapperremplace isUserInRoleet recherche l'utilisateur Authentication(qui est géré par Spring) pour savoir si l'utilisateur a un rôle ou non.

SecurityContextHolderAwareRequestWrapper le code est comme:

    @Override
    public boolean isUserInRole(String role) {
        return isGranted(role);
    }

 private boolean isGranted(String role) {
        Authentication auth = getAuthentication();

        if( rolePrefix != null ) {
            role = rolePrefix + role;
        }

        if ((auth == null) || (auth.getPrincipal() == null)) {
            return false;
        }

        Collection<? extends GrantedAuthority> authorities = auth.getAuthorities();

        if (authorities == null) {
            return false;
        }

        //This is the loop which do actual search
        for (GrantedAuthority grantedAuthority : authorities) {
            if (role.equals(grantedAuthority.getAuthority())) {
                return true;
            }
        }

        return false;
    }

Ces deux annotations ci-dessous sont égales, "hasRole" ajoutera automatiquement le préfixe "ROLE_". Assurez-vous d'avoir la bonne annotation. Ce rôle est défini dans UserDetailsService # loadUserByUsername.

@PreAuthorize("hasAuthority('ROLE_user')")
@PreAuthorize("hasRole('user')")

ensuite, vous pouvez obtenir le rôle dans le code java.

Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
if(authentication.getAuthorities().contains(new SimpleGrantedAuthority("ROLE_user"))){
    System.out.println("user role2");
}

Dans notre projet, nous utilisons une hiérarchie des rôles, alors que la plupart des réponses ci-dessus visent uniquement à vérifier un rôle spécifique, c'est-à-dire ne vérifieraient que le rôle donné, mais pas ce rôle et remonter la hiérarchie.

Une solution pour cela:

@Component
public class SpringRoleEvaluator {

@Resource(name="roleHierarchy")
private RoleHierarchy roleHierarchy;

public boolean hasRole(String role) {
    UserDetails dt = AuthenticationUtils.getSessionUserDetails();

    for (GrantedAuthority auth: roleHierarchy.getReachableGrantedAuthorities(dt.getAuthorities())) {
        if (auth.toString().equals("ROLE_"+role)) {
            return true;
        }
    }
    return false;
}

RoleHierarchy est défini comme un bean dans spring-security.xml.

Sur votre modèle utilisateur, ajoutez simplement une méthode 'hasRole' comme ci-dessous

public boolean hasRole(String auth) {
    for (Role role : roles) {
        if (role.getName().equals(auth)) { return true; }
    }
    return false;
}

Je l'utilise généralement pour vérifier si l'utilisateur authentifié a le rôle d'administrateur comme suit

Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); // This gets the authentication
User authUser = (User) authentication.getPrincipal(); // This gets the logged in user
authUser.hasRole("ROLE_ADMIN") // This returns true or false

Les rôles des utilisateurs peuvent être vérifiés des manières suivantes:

1. Utilisation des méthodes statiques d'appel dans SecurityContextHolder:

   Authentication auth = SecurityContextHolder.getContext().getAuthentication(); if (auth != null && auth.getAuthorities().stream().anyMatch(role -> role.getAuthority().equals("ROLE_NAME"))) { //do something}

2. Utilisation de HttpServletRequest

@GetMapping("/users")
public String getUsers(HttpServletRequest request) {
    if (request.isUserInRole("ROLE_NAME")) {
      
    }

Mon approche avec l'aide de Java8, passer des rôles séparés par une virgule vous donnera vrai ou faux

    public static Boolean hasAnyPermission(String permissions){
    Boolean result = false;
    if(permissions != null && !permissions.isEmpty()){
        String[] rolesArray = permissions.split(",");
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        for (String role : rolesArray) {
            boolean hasUserRole = authentication.getAuthorities().stream().anyMatch(r -> r.getAuthority().equals(role));
            if (hasUserRole) {
                result = true;
                break;
            }
        }
    }
    return result;
}