知識庫 / Spring / Spring Security RSS 訂閱

1. 概述

簡單來説，Spring Security 支持在方法級別上的權限語義。

通常，我們可以通過限制特定角色執行特定方法的權限來安全地保護我們的服務層，並使用專門的方法級安全測試支持進行測試。

在本教程中，我們將回顧一些安全註解的使用。然後我們將重點關注使用不同的策略測試我們的方法安全。

2. 啓用方法安全

首先，要使用 Spring Method Security，我們需要添加 spring-security-config 依賴項：

<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-config</artifactId>
</dependency>

我們可以在 Maven Central 找到其最新版本：https://mvnrepository.com/artifact/org.springframework.security/spring-security-config。

如果想要使用 Spring Boot，可以使用 spring-boot-starter-security 依賴，該依賴包含 spring-security-config：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

再次，最新版本可以在 Maven Central 找到。

接下來，我們需要啓用全局方法安全：

@Configuration
@EnableGlobalMethodSecurity(
  prePostEnabled = true, 
  securedEnabled = true, 
  jsr250Enabled = true)
public class MethodSecurityConfig 
  extends GlobalMethodSecurityConfiguration {
}

<ul>
 <li>The <em>prePostEnabled</em> 屬性啓用 Spring Security 的 pre/post 註解。</li>
 <li>The <em>securedEnabled</em> 屬性確定 <em>@Secured</em> 註解是否啓用。</li>
 <li>The <em>jsr250Enabled</em> 屬性允許我們使用 <em>@RoleAllowed</em> 註解。</li>
</ul>
<p>我們在下一部分將更深入地探討這些註解。</p>

3. Applying Method Security

This section describes how to apply method security to your application. Method security is a critical aspect of securing your application by controlling access to methods and preventing unauthorized access to sensitive data or functionality.

Key Concepts

• Method Security Policies: These policies define the rules governing access to specific methods.
• Access Control: Mechanisms that enforce the defined policies, determining which users or roles are permitted to execute a particular method.
• Security Context: The identity of the user or process executing the method.
• Least Privilege: Granting users and processes only the minimum necessary permissions to perform their tasks.

Implementing Method Security

There are several approaches to implementing method security:

• Access Control Lists (ACLs): ACLs associate permissions with methods, specifying which users or roles have access.
• Role-Based Access Control (RBAC): RBAC assigns permissions to roles, and users are assigned to roles.
• Attribute-Based Access Control (ABAC): ABAC uses attributes of the user, resource, and environment to determine access rights.

Example Code Snippet (Java)

public class UserService {

    // Method to retrieve user details
    public UserDetails getUserDetails(String userId) {
        // Access control logic here - check user permissions
        // ...
        return new UserDetails();
    }

    // Method to update user profile
    public void updateProfile(String userId, String newProfileData) {
        // Access control logic here - check user permissions
        // ...
    }
}

Note: The code above demonstrates a basic example. In a real-world application, you would implement more sophisticated access control logic based on your specific security requirements. Consider using a framework or library to simplify the implementation.

3.1. 使用 @Secured 註解

@Secured 註解用於指定方法的角色列表。因此，如果用户擁有該方法中指定的一項或多項角色，則她才能訪問該方法。

讓我們定義一個 getUsername 方法：

@Secured("ROLE_VIEWER")
public String getUsername() {
    SecurityContext securityContext = SecurityContextHolder.getContext();
    return securityContext.getAuthentication().getName();
}

此處 @Secured(“ROLE_VIEWER”) 註解定義只有擁有 ROLE_VIEWER 角色的用户才能執行 getUsername 方法。

此外，我們可以在 @Secured 註解中定義角色的列表：

@Secured({ "ROLE_VIEWER", "ROLE_EDITOR" })
public boolean isValidUsername(String username) {
    return userRoleRepository.isValidUsername(username);
}

在這種情況下，配置表明如果用户具有ROLE_VIEWER或ROLE_EDITOR角色，則該用户可以調用isValidUsername方法。

@Secured註解不支持Spring Expression Language (SpEL)。

3.2. 使用 @RolesAllowed 註解

@RolesAllowed 註解是 JSR-250 中與 @Secured 註解等效的註解。

基本上，我們可以像使用 @Secured 註解一樣，使用 @RolesAllowed 註解。

通過這種方式，我們可以重新定義 getUsername 和 isValidUsername 方法：

@RolesAllowed("ROLE_VIEWER")
public String getUsername2() {
    //...
}
    
@RolesAllowed({ "ROLE_VIEWER", "ROLE_EDITOR" })
public boolean isValidUsername2(String username) {
    //...
}

同樣，只有擁有 ROLE_VIEWER 角色的用户才能執行 getUsername2。

再次説明，用户只有在擁有至少一個 ROLE_VIEWER 或 ROLER_EDITOR 角色時，才能調用 isValidUsername2。

3.3. 使用 @PreAuthorize 和 @PostAuthorize 註解

@PreAuthorize 和 @PostAuthorize 註解都提供基於表達式的訪問控制。因此，可以使用 SpEL（Spring 表達式語言）編寫謂詞。

@PreAuthorize("hasRole('ROLE_VIEWER')")
public String getUsernameInUpperCase() {
    return getUsername().toUpperCase();
}

@PreAuthorize("hasRole('ROLE_VIEWER') or hasRole('ROLE_EDITOR')")
public boolean isValidUsername3(String username) {
    //...
}

@PreAuthorize("#username == authentication.principal.username")
public String getMyRoles(String username) {
    //...
}

@PostAuthorize("#username == authentication.principal.username")
public String getMyRoles2(String username) {
    //...
}

@PostAuthorize
  ("returnObject.username == authentication.principal.nickName")
public CustomUser loadUserDetail(String username) {
    return userRoleRepository.loadUserByUserName(username);
}

@PreFilter("filterObject != authentication.principal.username")
public String joinUsernames(List<String> usernames) {
    return usernames.stream().collect(Collectors.joining(";"));
}

在這裏，在我們的表達式中，我們使用 filterObject 屬性來表示當前集合中的對象。

但是，如果方法有多個集合類型的參數，則需要使用 filterTarget 屬性來指定要過濾的參數：

@PreFilter
  (value = "filterObject != authentication.principal.username",
  filterTarget = "usernames")
public String joinUsernamesAndRoles(
  List<String> usernames, List<String> roles) {
 
    return usernames.stream().collect(Collectors.joining(";")) 
      + ":" + roles.stream().collect(Collectors.joining(";"));
}

此外，我們還可以通過使用 @PostFilter 註解來過濾方法的返回集合：

@PostFilter("filterObject != authentication.principal.username")
public List<String> getAllUsernamesExceptCurrent() {
    return userRoleRepository.getAllUsernames();
}

在這種情況下，名稱 filterObject 指的是返回集合中的當前對象。

採用這種配置，Spring Security 將迭代返回的列表，並刪除與 principal 的用户名匹配的任何值。

我們的 Spring Security – @PreFilter 和 @PostFilter 文章詳細描述了這兩個註解。

3.5. 方法安全元註解

我們通常會遇到一種情況，即使用相同的安全配置來保護不同的方法。

在這種情況下，我們可以定義一個安全元註解：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@PreAuthorize("hasRole('VIEWER')")
public @interface IsViewer {
}

接下來，我們可以直接使用 @IsViewer 註解來保護我們的方法：

@IsViewer
public String getUsername4() {
    //...
}

安全元標註是一個很好的想法，因為它們增加了語義，並使我們的業務邏輯與安全框架解耦。

3.6. 類級別安全註解

如果我們在一個類中發現使用相同的安全註解對所有方法，我們應該考慮將該註解放在類級別。

@Service
@PreAuthorize("hasRole('ROLE_ADMIN')")
public class SystemService {

    public String getSystemYear(){
        //...
    }
 
    public String getSystemDate(){
        //...
    }
}

在上述示例中，安全規則 hasRole('ROLE_ADMIN') 將應用於 getSystemYear 和 getSystemDate 方法。

3.7. 方法上的多個安全註解

我們可以使用多個安全註解在一個方法上：

@PreAuthorize("#username == authentication.principal.username")
@PostAuthorize("returnObject.username == authentication.principal.nickName")
public CustomUser securedLoadUserDetail(String username) {
    return userRoleRepository.loadUserByUserName(username);
}

這樣一來，Spring 將在執行 securedLoadUserDetail 方法之前和之後都驗證授權。

4. 重要注意事項

關於方法安全，我們想強調以下兩點：

• 默認情況下，Spring AOP 代理用於應用方法安全。如果一個受保護的方法 A 被同一類中另一個方法調用，則方法 A 中的安全檢查將被完全忽略。這意味着方法 A 將不會執行任何安全檢查。同樣，這也適用於私有方法。
• Spring SecurityContext 是線程綁定的。默認情況下，安全上下文不會傳遞到子線程。有關更多信息，請參閲我們的 Spring Security Context Propagation 文章。

5. 測試安全方法

5.1. 配置

為了使用 JUnit 測試 Spring Security，我們需要 spring-security-test 依賴項。

<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-test</artifactId>
</dependency>

我們不需要指定依賴的版本，因為我們使用的是 Spring Boot 插件。可以在 Maven Central 找到該依賴的最新版本。

接下來，讓我們通過指定運行器和 ApplicationContext 配置來配置一個簡單的 Spring Integration 測試：

@RunWith(SpringRunner.class)
@ContextConfiguration
public class MethodSecurityIntegrationTest {
    // ...
}

5.2. 測試用户名和角色

現在我們的配置已準備就緒，讓我們嘗試測試我們使用 getUsername 方法，並使用 @Secured(“ROLE_VIEWER”) 註解進行安全保護的方法：

@Secured("ROLE_VIEWER")
public String getUsername() {
    SecurityContext securityContext = SecurityContextHolder.getContext();
    return securityContext.getAuthentication().getName();
}

由於我們在此處使用了 @Secured 註解，因此需要一個已認證的用户才能調用該方法。否則，我們將收到 AuthenticationCredentialsNotFoundException 異常。

因此，我們需要提供一個用户來測試我們的安全方法。

為了實現這一點，我們使用 @WithMockUser 裝飾測試方法，並提供用户和角色：

@Test
@WithMockUser(username = "john", roles = { "VIEWER" })
public void givenRoleViewer_whenCallGetUsername_thenReturnUsername() {
    String userName = userRoleService.getUsername();
    
    assertEquals("john", userName);
}

我們已提供一個經過身份驗證的用户，其用户名是 john, 其角色是 ROLE_VIEWER。如果未指定 username 或 role, 則默認 username 為 user, 默認 role 為 ROLE_USER。

請注意，這裏不需要添加 ROLE_ 前綴，因為 Spring Security 會自動添加該前綴。

如果不想使用該前綴，可以考慮使用 authority 代替 role。

例如，讓我們聲明一個 getUsernameInLowerCase 方法：

@PreAuthorize("hasAuthority('SYS_ADMIN')")
public String getUsernameLC(){
    return getUsername().toLowerCase();
}

我們可以使用權威數據進行測試。

@Test
@WithMockUser(username = "JOHN", authorities = { "SYS_ADMIN" })
public void givenAuthoritySysAdmin_whenCallGetUsernameLC_thenReturnUsername() {
    String username = userRoleService.getUsernameInLowerCase();

    assertEquals("john", username);
}

方便地，如果我們要使用同一個用户進行多個測試用例，可以在測試類中聲明 @WithMockUser 註解：

@RunWith(SpringRunner.class)
@ContextConfiguration
@WithMockUser(username = "john", roles = { "VIEWER" })
public class MockUserAtClassLevelIntegrationTest {
    //...
}

如果我們想以匿名用户的身份運行我們的測試，我們可以使用 註解:

@Test(expected = AccessDeniedException.class)
@WithAnonymousUser
public void givenAnomynousUser_whenCallGetUsername_thenAccessDenied() {
    userRoleService.getUsername();
}

public class CustomUser extends User {
    private String nickName;
    // getter and setter
}

@PostAuthorize("returnObject.username == authentication.principal.nickName")
public CustomUser loadUserDetail(String username) {
    return userRoleRepository.loadUserByUserName(username);
}

@Test
@WithUserDetails(
  value = "john", 
  userDetailsServiceBeanName = "userDetailService")
public void whenJohn_callLoadUserDetail_thenOK() {
 
    CustomUser user = userService.loadUserDetail("jane");

    assertEquals("jane", user.getNickName());
}

@Retention(RetentionPolicy.RUNTIME)
@WithMockUser(value = "john", roles = "VIEWER")
public @interface WithMockJohnViewer { }

@Test
@WithMockJohnViewer
public void givenMockedJohnViewer_whenCallGetUsername_thenReturnUsername() {
    String userName = userRoleService.getUsername();

    assertEquals("john", userName);
}