TOC

Ein benutzerdefinierter Sicherheitsausdruck mit Spring Security

Ein benutzerdefinierter Sicherheitsausdruck mit Spring Security

1. Überblick

In diesem Tutorial konzentrieren wir uns aufcreating a custom security expression with Spring Security.

Manchmal sindthe expressions available in the frameworkeinfach nicht aussagekräftig genug. In diesen Fällen ist es relativ einfach, einen neuen Ausdruck zu erstellen, der semantisch umfangreicher ist als die vorhandenen.

Wir werden zuerst diskutieren, wie Sie ein benutzerdefiniertesPermissionEvaluator erstellen, dann einen vollständig benutzerdefinierten Ausdruck - und schließlich, wie Sie einen der integrierten Sicherheitsausdrücke überschreiben.

2. Eine Benutzerentität

Bereiten wir zunächst die Grundlage für die Erstellung der neuen Sicherheitsausdrücke vor.

Werfen wir einen Blick auf unsereUser-Entität, diePrivileges undOrganization hat: 

@Entity
public class User{
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    private String password;

    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(name = "users_privileges",
      joinColumns =
        @JoinColumn(name = "user_id", referencedColumnName = "id"),
      inverseJoinColumns =
        @JoinColumn(name = "privilege_id", referencedColumnName = "id"))
    private Set privileges;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "organization_id", referencedColumnName = "id")
    private Organization organization;

    // standard getters and setters
}

Und hier sind unsere einfachenPrivilege: 

@Entity
public class Privilege {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(nullable = false, unique = true)
    private String name;

    // standard getters and setters
}

Und unsereOrganization: 

@Entity
public class Organization {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(nullable = false, unique = true)
    private String name;

    // standard setters and getters
}

Schließlich verwenden wir ein einfacheres benutzerdefiniertesPrincipal: 

public class MyUserPrincipal implements UserDetails {

    private User user;

    public MyUserPrincipal(User user) {
        this.user = user;
    }

    @Override
    public String getUsername() {
        return user.getUsername();
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public Collection getAuthorities() {
        List authorities = new ArrayList();
        for (Privilege privilege : user.getPrivileges()) {
            authorities.add(new SimpleGrantedAuthority(privilege.getName()));
        }
        return authorities;
    }

    ...
}

Wenn alle diese Klassen fertig sind, werden wir unsere benutzerdefiniertenPrincipal in einer grundlegendenUserDetailsService-Implementierung verwenden: 

@Service
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException(username);
        }
        return new MyUserPrincipal(user);
    }
}

Wie Sie sehen, sind diese Beziehungen nicht kompliziert - der Benutzer verfügt über eine oder mehrere Berechtigungen, und jeder Benutzer gehört einer Organisation an.

3. Dateneinrichtung

Als nächstes initialisieren wir unsere Datenbank mit einfachen Testdaten: 

@Component
public class SetupData {
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PrivilegeRepository privilegeRepository;

    @Autowired
    private OrganizationRepository organizationRepository;

    @PostConstruct
    public void init() {
        initPrivileges();
        initOrganizations();
        initUsers();
    }
}

Hier sind unsereinitMethoden: 

private void initPrivileges() {
    Privilege privilege1 = new Privilege("FOO_READ_PRIVILEGE");
    privilegeRepository.save(privilege1);

    Privilege privilege2 = new Privilege("FOO_WRITE_PRIVILEGE");
    privilegeRepository.save(privilege2);
}
private void initOrganizations() {
    Organization org1 = new Organization("FirstOrg");
    organizationRepository.save(org1);

    Organization org2 = new Organization("SecondOrg");
    organizationRepository.save(org2);
}
private void initUsers() {
    Privilege privilege1 = privilegeRepository.findByName("FOO_READ_PRIVILEGE");
    Privilege privilege2 = privilegeRepository.findByName("FOO_WRITE_PRIVILEGE");

    User user1 = new User();
    user1.setUsername("john");
    user1.setPassword("123");
    user1.setPrivileges(new HashSet(Arrays.asList(privilege1)));
    user1.setOrganization(organizationRepository.findByName("FirstOrg"));
    userRepository.save(user1);

    User user2 = new User();
    user2.setUsername("tom");
    user2.setPassword("111");
    user2.setPrivileges(new HashSet(Arrays.asList(privilege1, privilege2)));
    user2.setOrganization(organizationRepository.findByName("SecondOrg"));
    userRepository.save(user2);
}

Beachten Sie, dass:

  • Benutzer "john" hat nurFOO_READ_PRIVILEGE

  • Benutzer "tom" hat sowohlFOO_READ_PRIVILEGE als auchFOO_WRITE_PRIVILEGE

4. Ein benutzerdefinierter Berechtigungsauswerter

An diesem Punkt können wir mit der Implementierung unseres neuen Ausdrucks beginnen - über einen neuen, benutzerdefinierten Berechtigungsauswerter.

Wir werden die Berechtigungen des Benutzers verwenden, um unsere Methoden zu sichern. Anstatt fest codierte Berechtigungsnamen zu verwenden, möchten wir eine offenere und flexiblere Implementierung erreichen.

Lass uns anfangen.

4.1. PermissionEvaluator

Um unseren eigenen benutzerdefinierten Berechtigungsauswerter zu erstellen, müssen wir diePermissionEvaluator-Schnittstelle implementieren: 

public class CustomPermissionEvaluator implements PermissionEvaluator {
    @Override
    public boolean hasPermission(
      Authentication auth, Object targetDomainObject, Object permission) {
        if ((auth == null) || (targetDomainObject == null) || !(permission instanceof String)){
            return false;
        }
        String targetType = targetDomainObject.getClass().getSimpleName().toUpperCase();

        return hasPrivilege(auth, targetType, permission.toString().toUpperCase());
    }

    @Override
    public boolean hasPermission(
      Authentication auth, Serializable targetId, String targetType, Object permission) {
        if ((auth == null) || (targetType == null) || !(permission instanceof String)) {
            return false;
        }
        return hasPrivilege(auth, targetType.toUpperCase(),
          permission.toString().toUpperCase());
    }
}

Hier ist unserehasPrivilege()Methode: 

private boolean hasPrivilege(Authentication auth, String targetType, String permission) {
    for (GrantedAuthority grantedAuth : auth.getAuthorities()) {
        if (grantedAuth.getAuthority().startsWith(targetType)) {
            if (grantedAuth.getAuthority().contains(permission)) {
                return true;
            }
        }
    }
    return false;
}

Wir haben jetzt einen neuen Sicherheitsausdruck zur Verfügung, der verwendet werden kann:hasPermission.

Und so, anstatt die stärker codierte Version zu verwenden: 

@PostAuthorize("hasAuthority('FOO_READ_PRIVILEGE')")

Wir können verwenden: 

@PostAuthorize("hasPermission(returnObject, 'read')")

or 

@PreAuthorize("hasPermission(#id, 'Foo', 'read')")

Hinweis:#id bezieht sich auf den Methodenparameter und 'Foo' bezieht sich auf den Zielobjekttyp.

4.2. Methodensicherheitskonfiguration

Es reicht nicht aus, dieCustomPermissionEvaluator zu definieren - wir müssen sie auch in unserer Methodensicherheitskonfiguration verwenden: 

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {

    @Override
    protected MethodSecurityExpressionHandler createExpressionHandler() {
        DefaultMethodSecurityExpressionHandler expressionHandler =
          new DefaultMethodSecurityExpressionHandler();
        expressionHandler.setPermissionEvaluator(new CustomPermissionEvaluator());
        return expressionHandler;
    }
}

4.3. Beispiel in der Praxis

Lassen Sie uns nun den neuen Ausdruck in einigen einfachen Controller-Methoden verwenden: 

@Controller
public class MainController {

    @PostAuthorize("hasPermission(returnObject, 'read')")
    @RequestMapping(method = RequestMethod.GET, value = "/foos/{id}")
    @ResponseBody
    public Foo findById(@PathVariable long id) {
        return new Foo("Sample");
    }

    @PreAuthorize("hasPermission(#foo, 'write')")
    @RequestMapping(method = RequestMethod.POST, value = "/foos")
    @ResponseStatus(HttpStatus.CREATED)
    @ResponseBody
    public Foo create(@RequestBody Foo foo) {
        return foo;
    }
}

Und los geht's - wir sind alle bereit und verwenden den neuen Ausdruck in der Praxis. __

4.4. Der Live-Test

Schreiben wir jetzt einen einfachen Live-Test - treffen Sie die API und stellen Sie sicher, dass alles funktioniert: 

@Test
public void givenUserWithReadPrivilegeAndHasPermission_whenGetFooById_thenOK() {
    Response response = givenAuth("john", "123").get("http://localhost:8081/foos/1");
    assertEquals(200, response.getStatusCode());
    assertTrue(response.asString().contains("id"));
}

@Test
public void givenUserWithNoWritePrivilegeAndHasPermission_whenPostFoo_thenForbidden() {
    Response response = givenAuth("john", "123").contentType(MediaType.APPLICATION_JSON_VALUE)
                                                .body(new Foo("sample"))
                                                .post("http://localhost:8081/foos");
    assertEquals(403, response.getStatusCode());
}

@Test
public void givenUserWithWritePrivilegeAndHasPermission_whenPostFoo_thenOk() {
    Response response = givenAuth("tom", "111").contentType(MediaType.APPLICATION_JSON_VALUE)
                                               .body(new Foo("sample"))
                                               .post("http://localhost:8081/foos");
    assertEquals(201, response.getStatusCode());
    assertTrue(response.asString().contains("id"));
}

Und hier ist unseregivenAuth()-Methode: 

private RequestSpecification givenAuth(String username, String password) {
    FormAuthConfig formAuthConfig =
      new FormAuthConfig("http://localhost:8081/login", "username", "password");

    return RestAssured.given().auth().form(username, password, formAuthConfig);
}

5. Ein neuer Sicherheitsausdruck

Mit der vorherigen Lösung konnten wir den AusdruckhasPermissiondefinieren und verwenden - was sehr nützlich sein kann.

Wir sind hier jedoch durch den Namen und die Semantik des Ausdrucks selbst noch etwas eingeschränkt.

In diesem Abschnitt werden wir also vollständig benutzerdefiniert - und wir werden einen Sicherheitsausdruck namensisMember() implementieren - und prüfen, ob der Principal Mitglied einer Organisation ist. __

5.1. Sicherheitsausdruck für benutzerdefinierte Methoden

Um diesen neuen benutzerdefinierten Ausdruck zu erstellen, müssen wir zunächst den Stammsatz implementieren, in dem die Auswertung aller Sicherheitsausdrücke beginnt: 

public class CustomMethodSecurityExpressionRoot
  extends SecurityExpressionRoot implements MethodSecurityExpressionOperations {

    public CustomMethodSecurityExpressionRoot(Authentication authentication) {
        super(authentication);
    }

    public boolean isMember(Long OrganizationId) {
        User user = ((MyUserPrincipal) this.getPrincipal()).getUser();
        return user.getOrganization().getId().longValue() == OrganizationId.longValue();
    }

    ...
}

Nun, wie wir diese neue Operation direkt im Grundton zur Verfügung gestellt haben; isMember() wird verwendet, um zu überprüfen, ob der aktuelle Benutzer Mitglied inOrganization ist.

Beachten Sie auch, wie wir dieSecurityExpressionRoot erweitert haben, um auch die integrierten Ausdrücke einzuschließen.

5.2. Benutzerdefinierter Ausdruckshandler

Als nächstes müssen wir unsereCustomMethodSecurityExpressionRoot in unseren Ausdruckshandler injizieren: 

public class CustomMethodSecurityExpressionHandler
  extends DefaultMethodSecurityExpressionHandler {
    private AuthenticationTrustResolver trustResolver =
      new AuthenticationTrustResolverImpl();

    @Override
    protected MethodSecurityExpressionOperations createSecurityExpressionRoot(
      Authentication authentication, MethodInvocation invocation) {
        CustomMethodSecurityExpressionRoot root =
          new CustomMethodSecurityExpressionRoot(authentication);
        root.setPermissionEvaluator(getPermissionEvaluator());
        root.setTrustResolver(this.trustResolver);
        root.setRoleHierarchy(getRoleHierarchy());
        return root;
    }
}

5.3. Methodensicherheitskonfiguration

Jetzt müssen wir unsereCustomMethodSecurityExpressionHandler in der Methodensicherheitskonfiguration verwenden: 

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {
    @Override
    protected MethodSecurityExpressionHandler createExpressionHandler() {
        CustomMethodSecurityExpressionHandler expressionHandler =
          new CustomMethodSecurityExpressionHandler();
        expressionHandler.setPermissionEvaluator(new CustomPermissionEvaluator());
        return expressionHandler;
    }
}

5.4. Verwenden des neuen Ausdrucks

Hier ist ein einfaches Beispiel, um unsere Controller-Methode mitisMember() zu sichern: 

@PreAuthorize("isMember(#id)")
@RequestMapping(method = RequestMethod.GET, value = "/organizations/{id}")
@ResponseBody
public Organization findOrgById(@PathVariable long id) {
    return organizationRepository.findOne(id);
}

5.5. Live-Test

Zum Schluss noch ein einfacher Live-Test für Benutzer „john“: 

@Test
public void givenUserMemberInOrganization_whenGetOrganization_thenOK() {
    Response response = givenAuth("john", "123").get("http://localhost:8081/organizations/1");
    assertEquals(200, response.getStatusCode());
    assertTrue(response.asString().contains("id"));
}

@Test
public void givenUserMemberNotInOrganization_whenGetOrganization_thenForbidden() {
    Response response = givenAuth("john", "123").get("http://localhost:8081/organizations/2");
    assertEquals(403, response.getStatusCode());
}

6. Deaktivieren Sie einen integrierten Sicherheitsausdruck

Lassen Sie uns abschließend sehen, wie Sie einen integrierten Sicherheitsausdruck überschreiben. Wir werden das Deaktivieren vonhasAuthority() erläutern.

6.1. Benutzerdefinierter Sicherheitsausdruck Root

In ähnlicher Weise beginnen wir mit dem Schreiben unserer eigenenSecurityExpressionRoot - hauptsächlich, weil die integrierten Methodenfinal sind und wir sie daher nicht überschreiben können: 

public class MySecurityExpressionRoot implements MethodSecurityExpressionOperations {
    public MySecurityExpressionRoot(Authentication authentication) {
        if (authentication == null) {
            throw new IllegalArgumentException("Authentication object cannot be null");
        }
        this.authentication = authentication;
    }

    @Override
    public final boolean hasAuthority(String authority) {
        throw new RuntimeException("method hasAuthority() not allowed");
    }
    ...
}

Nachdem wir diesen Grundton definiert haben, müssen wir ihn in den Ausdruckshandler einfügen und diesen Handler dann in unsere Konfiguration einbinden - genau wie oben in Abschnitt 5 beschrieben.

6.2. Beispiel - Verwenden des Ausdrucks

Wenn wir nunhasAuthority() zum Sichern von Methoden verwenden möchten, wird wie folgtRuntimeException ausgelöst, wenn wir versuchen, auf die Methode zuzugreifen: 

@PreAuthorize("hasAuthority('FOO_READ_PRIVILEGE')")
@RequestMapping(method = RequestMethod.GET, value = "/foos")
@ResponseBody
public Foo findFooByName(@RequestParam String name) {
    return new Foo(name);
}

6.3. Live-Test

Zum Schluss hier unser einfacher Test: 

@Test
public void givenDisabledSecurityExpression_whenGetFooByName_thenError() {
    Response response = givenAuth("john", "123").get("http://localhost:8081/foos?name=sample");
    assertEquals(500, response.getStatusCode());
    assertTrue(response.asString().contains("method hasAuthority() not allowed"));
}

7. Fazit

In diesem Handbuch haben wir uns eingehend mit den verschiedenen Möglichkeiten befasst, wie wir einen benutzerdefinierten Sicherheitsausdruck in Spring Security implementieren können, wenn die vorhandenen nicht ausreichen.

Und wie immer kann der vollständige Quellcodeover on GitHub gefunden werden.

Related