在本文中，我們將探索 Spring 安全性，并使用 OAuth 2.0 構建一個身份驗證系統(tǒng)。

Spring Security 是一個功能強大、高度可定制的框架，用于在基于 Java 的應用程序中實現(xiàn)強大的身份驗證和訪問控制機制。它是 Spring 生態(tài)系統(tǒng)的核心組件，廣泛用于保護 Web 應用程序、REST API 和其他后端服務的安全。借助 Spring Security，您可以為在應用程序中構建和實施安全實踐奠定堅實的基礎。

---

Spring Security 的工作原理

在深入了解 Spring Security 的運行方式之前，了解基于 Java 的 Web 服務器中的請求處理生命周期至關重要。 Spring Security 無縫集成到此生命周期中以保護傳入請求。

---

使用 Spring Security 處理請求生命周期

使用 Spring Security 在基于 Spring 的應用程序中處理 HTTP 請求的生命周期涉及多個階段，每個階段在處理、驗證和保護請求方面都發(fā)揮著關鍵作用。

---

1. 客戶請求

當客戶端（例如瀏覽器、移動應用程序或 Postman 等 API 工具）向服務器發(fā)送 HTTP 請求時，生命周期就開始了。

示例：

GET /api/admin/dashboard HTTP/1.1

---

2. Servlet 容器

Servlet 容器（例如 Tomcat）接收請求并將其委托給 DispatcherServlet（Spring 應用程序中的前端控制器）。這是應用程序處理管道開始的地方。

---

3. Spring Security 過濾器鏈

在 DispatcherServlet 處理請求之前，Spring Security 的過濾器鏈 會攔截它。過濾器鏈是一系列過濾器，每個過濾器負責處理特定的安全任務。這些過濾器確保請求在到達應用程序邏輯之前滿足身份驗證和授權要求。

鏈中的關鍵過濾器：

1. 身份驗證過濾器:
   
   這些過濾器驗證請求是否包含有效的憑據(jù)，例如用戶名/密碼、JWT 或會話 cookie。

2. 授權過濾器：
   
   身份驗證后，這些過濾器確保經(jīng)過身份驗證的用戶具有訪問所請求資源所需的角色或權限。

3. 其他濾鏡：

* **CsrfFilter**: Validates CSRF tokens to prevent Cross-Site Request Forgery attacks.

* **CorsFilter**: Manages Cross-Origin Resource Sharing (CORS) rules for secure API access from different domains.

* **ExceptionTranslationFilter**: Handles security-related exceptions (e.g., invalid credentials) and sends appropriate responses to the client.

---

4. 安全上下文

如果身份驗證成功，Spring Security 將創(chuàng)建一個 Authentication 對象并將其存儲在 SecurityContext 中。該對象通常存儲在線程本地存儲中，在整個請求生命周期中都可以訪問。

身份驗證對象：

• Principal：代表經(jīng)過身份驗證的用戶（例如用戶名）。

• 憑據(jù)：包括 JWT 令牌或密碼等身份驗證詳細信息。

• 權限：包含分配給用戶的角色和權限。

過濾器鏈中的示例流程：

• 請求通過身份驗證過濾器。

• 如果憑據(jù)有效，則會創(chuàng)建 Authentication 對象并將其添加到 SecurityContext。

• 如果憑據(jù)無效，ExceptionTranslationFilter 會向客戶端發(fā)送 401 未經(jīng)授權的響應。

---

5. DispatcherServlet

一旦請求成功通過 Spring Security 過濾器鏈，DispatcherServlet 就會接管：

1. 處理程序映射:
   
   它根據(jù) URL 和 HTTP 方法將傳入請求映射到適當?shù)目刂破鞣椒ā?/p>

2. 控制器調用:
   
   映射的控制器通常在服務和存儲庫等其他 Spring 組件的幫助下處理請求并返回適當?shù)捻憫?/p>

Spring Security 如何融入生命周期

Spring Security 通過其過濾器將自身集成到此生命周期中，在最早階段攔截請求。當請求到達應用程序邏輯時，它已經(jīng)經(jīng)過身份驗證和授權，確保核心應用程序僅處理合法流量。

---

Spring Security 的設計確保以聲明方式處理身份驗證、授權和其他安全措施，使開發(fā)人員能夠根據(jù)需要靈活地自定義或擴展其行為。它不僅強制執(zhí)行最佳實踐，還簡化了現(xiàn)代應用程序中復雜安全要求的實現(xiàn)。

Spring Security 組件：超越過濾器鏈

探索了 Spring Security 中的過濾器鏈之后，讓我們深入研究一些在身份驗證和授權過程中發(fā)揮關鍵作用的其他關鍵組件。

認證管理器

AuthenticationManager 是一個定義單個方法的接口，authenticate(Authenticationauthentication)，用于驗證用戶的憑據(jù)并確定它們是否有效。您可以將 AuthenticationManager 視為一個協(xié)調器，您可以在其中注冊多個提供商，并且根據(jù)請求類型，它將向正確的提供商發(fā)送身份驗證請求。

認證提供者

AuthenticationProvider 是一個接口，它定義了一個合約，用于根據(jù)用戶的憑據(jù)對用戶進行身份驗證。它代表特定的身份驗證機制，例如用戶名/密碼、OAuth 或 LDAP。多個 AuthenticationProvider 實現(xiàn)可以共存，允許應用程序支持各種身份驗證策略。

核心概念：

1. 身份驗證對象:
   
   AuthenticationProvider 處理 Authentication 對象，該對象封裝了用戶的憑據(jù)（例如用戶名和密碼）。

2. 驗證方法:
   
   每個 AuthenticationProvider 都實現(xiàn)了authenticate(Authenticationauthentication)方法，實際的身份驗證邏輯駐留在其中。此方法：

* **CsrfFilter**: Validates CSRF tokens to prevent Cross-Site Request Forgery attacks.

* **CorsFilter**: Manages Cross-Origin Resource Sharing (CORS) rules for secure API access from different domains.

* **ExceptionTranslationFilter**: Handles security-related exceptions (e.g., invalid credentials) and sends appropriate responses to the client.

1. 支持方法： support(Class>authentication) 方法指示 AuthenticationProvider 是否可以處理給定類型的身份驗證。這允許 Spring Security 確定正確的提供者來處理特定的身份驗證請求。

示例：

• 數(shù)據(jù)庫支持的 AuthenticationProvider 驗證用戶名和密碼。

• 基于 OAuth 的 AuthenticationProvider 驗證外部身份提供商頒發(fā)的令牌。

用戶詳情服務

UserDetailsS??ervice 在 Spring 文檔中被描述為加載用戶特定數(shù)據(jù)的核心接口，它包含一個方法 loadUserByUsername ，該方法接受用戶名作為參數(shù)并返回 ==User== 身份對象?；旧衔覀儎?chuàng)建并實現(xiàn)了 UserDetailsS??ervice 的類，在其中重寫了 loadUserByUsername 方法。

* Validates the user’s credentials.

* Returns an authenticated `Authentication` object upon success.

* Throws an `AuthenticationException` if authentication fails.

現(xiàn)在這三者如何協(xié)同工作的是 AuthenticationManager 會要求 AuthenticationProvider 根據(jù)指定的 Provider 類型進行身份驗證，而 UserDetailsS??ervice 實現(xiàn)將幫助 AuthenticationProvider 證明用戶詳細信息。

現(xiàn)在，在進行配置和所有內容之前，這里是基于 JWT 身份驗證的 Spring Security 的簡明流程：

1. 用戶請求

• 用戶使用其憑據(jù)（用戶名和密碼）或 JWT 令牌（標頭中）向經(jīng)過身份驗證的端點發(fā)送請求，并將請求傳遞到身份驗證過濾器

• AuthenticationFilter（例如，UsernamePasswordAuthenticationFilter）：

  • 根據(jù)提交的憑據(jù)（通常以用戶名和密碼的形式）處理用戶身份驗證。這就是 UsernamePasswordAuthenticationFilter 發(fā)揮作用的地方。
  • 它監(jiān)聽請求，提取用戶名和密碼，并將它們傳遞給 AuthenticationManager。
  • 但是我們沒有傳遞用戶名和密碼，我們只給出令牌，因此在此 AuthenticationFilter 之前應該有一個過濾器，它將告訴身份驗證過程用戶已通過身份驗證，無需檢查用戶名和密碼，這通過創(chuàng)建 JWTFilter
  來完成

2.JWT過濾器

這個自定義過濾器擴展了 OncePerRequestFilter 并放置在 UsernamePasswordAuthenticationFilter 之前，它的作用是從請求中提取令牌并驗證它。

如果令牌有效，它會創(chuàng)建一個 UsernamePasswordAuthenticationToken 并將該令牌設置到安全上下文中，告訴 Spring Security 該請求已通過身份驗證，并且當此請求傳遞到 UsernamePasswordAuthenticationFilter 時，它只是傳遞，因為它具有 UsernamePasswordAuthenticationToken

* **CsrfFilter**: Validates CSRF tokens to prevent Cross-Site Request Forgery attacks.

* **CorsFilter**: Manages Cross-Origin Resource Sharing (CORS) rules for secure API access from different domains.

* **ExceptionTranslationFilter**: Handles security-related exceptions (e.g., invalid credentials) and sends appropriate responses to the client.

如果我們在 UserDetails 類的幫助下驗證用戶名和密碼后傳遞了用戶名和密碼而不是令牌，則此 UsernamePasswordAuthenticationToken 是在 AuthenticationManager 和 AuthenticationProvider 的幫助下生成的。

3. 身份驗證管理器

• AuthenticationManager：它接收身份驗證請求并將其委托給我們配置的適當?shù)?AuthenticationProvider。

* Validates the user’s credentials.

* Returns an authenticated `Authentication` object upon success.

* Throws an `AuthenticationException` if authentication fails.

4. 身份驗證提供程序

• UserDetailsS??ervice：AuthenticationProvider 使用 UserDetailsS??ervice 根據(jù)用戶名加載用戶詳細信息。我們?yōu)榇颂峁┝?UserDetailsS??ervice

的實現(xiàn)

• 憑證驗證：它將提供的密碼與存儲在用戶詳細信息中的密碼進行比較（通常使用密碼編碼器）。
  

package com.oauth.backend.services;

import com.oauth.backend.entities.User;
import com.oauth.backend.repositories.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Component;


@Component
public class CustomUserDetailsService implements UserDetailsService {
    private final UserRepository userRepository;

    public CustomUserDetailsService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

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

        User user = userRepository.findByUsername(username);
        if(user==null){
            throw new UsernameNotFoundException(username);
        }
        return new UserDetailsImpl(user);
    }
    public UserDetails loadUserByEmail(String email) throws UsernameNotFoundException {
        User user = userRepository.findByEmail(email);
        if(user==null){
            throw new UsernameNotFoundException(email);
        }
        return new UserDetailsImpl(user);
    }
}

現(xiàn)在需要配置所有這些不同的過濾器和 bean，以便 Spring security 知道要做什么，因此我們創(chuàng)建一個配置類，在其中指定所有配置。

@Component
public class JWTFilter extends OncePerRequestFilter {

    private final JWTService jwtService;
    private final UserDetailsService userDetailsService;
    public JWTFilter(JWTService jwtService,UserDetailsService userDetailsService) {
        this.jwtService = jwtService;
        this.userDetailsService = userDetailsService;
    }
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        final String authHeader = request.getHeader("Authorization");

        if(authHeader == null || !authHeader.startsWith("Bearer")) {
            filterChain.doFilter(request,response);
            return;
        }

        final String jwt = authHeader.substring(7);
        final String userName = jwtService.extractUserName(jwt);

        Authentication authentication
                = SecurityContextHolder.getContext().getAuthentication();

        if(userName !=null  && authentication == null) {
            //Authenticate
            UserDetails userDetails
                    = userDetailsService.loadUserByUsername(userName);

            if(jwtService.isTokenValid(jwt,userDetails)) {
                UsernamePasswordAuthenticationToken authenticationToken
                        = new UsernamePasswordAuthenticationToken(
                        userDetails,
                        null,
                        userDetails.getAuthorities()
                );

                SecurityContextHolder.getContext()
                        .setAuthentication(authenticationToken);
            }
        }

        filterChain.doFilter(request,response);
    }



}

到目前為止，我們已經(jīng)在 Spring Security 的幫助下理解并配置了我們的身份驗證，現(xiàn)在是時候測試它了。

我們將創(chuàng)建一個簡單的應用程序，其中包含兩個控制器 AuthController（處理登錄和注冊）和 ProductController（虛擬受保護控制器）

* **CsrfFilter**: Validates CSRF tokens to prevent Cross-Site Request Forgery attacks.

* **CorsFilter**: Manages Cross-Origin Resource Sharing (CORS) rules for secure API access from different domains.

* **ExceptionTranslationFilter**: Handles security-related exceptions (e.g., invalid credentials) and sends appropriate responses to the client.

* Validates the user’s credentials.

* Returns an authenticated `Authentication` object upon success.

* Throws an `AuthenticationException` if authentication fails.

package com.oauth.backend.services;

import com.oauth.backend.entities.User;
import com.oauth.backend.repositories.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Component;


@Component
public class CustomUserDetailsService implements UserDetailsService {
    private final UserRepository userRepository;

    public CustomUserDetailsService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

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

        User user = userRepository.findByUsername(username);
        if(user==null){
            throw new UsernameNotFoundException(username);
        }
        return new UserDetailsImpl(user);
    }
    public UserDetails loadUserByEmail(String email) throws UsernameNotFoundException {
        User user = userRepository.findByEmail(email);
        if(user==null){
            throw new UsernameNotFoundException(email);
        }
        return new UserDetailsImpl(user);
    }
}

@Component
public class JWTFilter extends OncePerRequestFilter {

    private final JWTService jwtService;
    private final UserDetailsService userDetailsService;
    public JWTFilter(JWTService jwtService,UserDetailsService userDetailsService) {
        this.jwtService = jwtService;
        this.userDetailsService = userDetailsService;
    }
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        final String authHeader = request.getHeader("Authorization");

        if(authHeader == null || !authHeader.startsWith("Bearer")) {
            filterChain.doFilter(request,response);
            return;
        }

        final String jwt = authHeader.substring(7);
        final String userName = jwtService.extractUserName(jwt);

        Authentication authentication
                = SecurityContextHolder.getContext().getAuthentication();

        if(userName !=null  && authentication == null) {
            //Authenticate
            UserDetails userDetails
                    = userDetailsService.loadUserByUsername(userName);

            if(jwtService.isTokenValid(jwt,userDetails)) {
                UsernamePasswordAuthenticationToken authenticationToken
                        = new UsernamePasswordAuthenticationToken(
                        userDetails,
                        null,
                        userDetails.getAuthorities()
                );

                SecurityContextHolder.getContext()
                        .setAuthentication(authenticationToken);
            }
        }

        filterChain.doFilter(request,response);
    }



}

@Bean  
public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception{  
return config.getAuthenticationManager();  
}

@Bean  
public AuthenticationProvider authenticationProvider(){  
DaoAuthenticationProvider authenticationProvider = new DaoAuthenticationProvider();  
authenticationProvider.setUserDetailsService(userDetailsServiceImpl);  
authenticationProvider.setPasswordEncoder(passwordEncoder);  
return authenticationProvider;  
}

到目前為止，我們已經(jīng)實現(xiàn)了注冊、登錄和驗證，但是如果我還想添加 Login With Google/Github 功能，那么我們可以借助 OAuth2.0 來實現(xiàn)

OAuth 2.0

OAuth 2.0 是一種用于授權的協(xié)議，通過它，用戶可以授予第三方應用程序訪問存儲在其他平臺（例如 Google Drive、Github）上的資源的權限，而無需共享這些平臺的憑據(jù)。

它主要用于啟用社交登錄，例如“使用 google 登錄”、“使用 github 登錄”。

Google、Facebook、Github 等平臺提供了授權服務器，該服務器實現(xiàn)了 OAuth 2.0 協(xié)議，用于此社交登錄或授權訪問。

OAuth 2.0 的關鍵概念

• 資源所有者

• 客戶

• 授權服務器

• 資源服務器

• 訪問令牌

• 范圍

• 補助金

現(xiàn)在我們將一一研究每個概念

資源所有者

資源所有者是想要授權第三方應用程序（您的應用程序）的用戶。

客戶

這是您的（第三方）應用程序想要從資源服務器訪問數(shù)據(jù)或資源。

資源服務器

它是存儲用戶數(shù)據(jù)的服務器，供第三方應用程序訪問。

授權服務器

對資源所有者進行身份驗證并向客戶端（例如 Google 帳戶）頒發(fā)訪問令牌的服務器。

訪問令牌

授權服務器向客戶端頒發(fā)的憑證，允許客戶端代表用戶訪問資源服務器。它的生命周期通常很短，很快就會過期，因此還提供了刷新令牌來刷新此訪問令牌，以便用戶不需要再次授權。

范圍

用戶授予的特定權限，定義客戶端可以和不能對用戶數(shù)據(jù)執(zhí)行什么操作。例如，對于授權，我們只需要用戶信息，如個人資料、姓名等，但對于文件訪問，需要不同的范圍。

補助金

客戶端應用程序從授權服務器獲取訪問令牌的方法。授權定義了授權客戶端應用程序訪問資源所有者的受保護數(shù)據(jù)的流程和條件。

它是安全的，因為我們不需要向瀏覽器公開我們的客戶端密鑰和其他憑據(jù)

OAuth 2.0 提供了兩種最常用的 Grant 類型

1. 授權碼授予

   它是最常用的授權/方法類型，最安全，并且適用于服務器端應用程序

   在此，授權碼由客戶端提供給后端，后端將訪問令牌提供給客戶端。

   流程：

   1. 客戶端將用戶重定向到授權服務器。
   2. 用戶登錄并同意。
   3. 授權服務器發(fā)出授權碼。
   4. 客戶端與后端交換授權代碼以獲取訪問令牌。

2. 隱性授予

   由單頁應用程序 (SPA) 或沒有后端的應用程序使用。在此，訪問令牌是在瀏覽器本身中直接生成和頒發(fā)的。

   流程：

   1. 客戶端將用戶重定向到授權服務器。
   2. 用戶登錄并同意。
   3. 授權服務器直接頒發(fā)訪問令牌。

為了完全理解，我們將分別實現(xiàn)兩者，但首先我們將實現(xiàn)我們需要的授權代碼授予

1. 授權服務器

   它可以是任何一個平臺（例如 google 、 github），或者您也可以使用 KeyCloak 創(chuàng)建自己的平臺，或者也可以遵循 OAuth 2.0 標準構建您自己的平臺（我們可能會在下一篇博客中這樣做？）

2. Spring Boot 應用

   這將是我們的主要后端應用程序/服務，它將處理代碼交換、驗證、保存用戶詳細信息和分配 JWT 令牌等所有操作

3. React 應用程序（前端）

   這將是我們的客戶端，它將用戶重定向到授權服務器進行授權。

因此，在我們的實現(xiàn)中，我們要做的是前端（網(wǎng)絡/應用程序）將我們的用戶重定向到谷歌登錄，并將 uri 重定向到我們的后端端點，這將進一步控制我們稍后將討論它以及redirect_url我們還傳遞應用程序的客戶端 ID，所有這些都將在查詢參數(shù)中發(fā)送。

否，當用戶成功登錄谷歌時，授權服務器（谷歌的）會將我們的請求重定向到后端端點，我們要做的就是與授權服務器交換授權代碼以獲取訪問令牌和刷新令牌，然后我們可以根據(jù)需要處理身份驗證，最后我們會將響應發(fā)送回我們的前端，該前端將有一個 cookie 并重定向到我們的儀表板，或者可能是受保護的頁面。

現(xiàn)在我們將研究代碼，但請確保在 OAuth 客戶端的 Google 控制臺儀表板中的授權重定向 URL 中添加后端端點的 URL。

* **CsrfFilter**: Validates CSRF tokens to prevent Cross-Site Request Forgery attacks.

* **CorsFilter**: Manages Cross-Origin Resource Sharing (CORS) rules for secure API access from different domains.

* **ExceptionTranslationFilter**: Handles security-related exceptions (e.g., invalid credentials) and sends appropriate responses to the client.

就是這樣，它可以正常工作，為了測試，您可以制作一個簡單的前端應用程序，它除了具有上下文之外什么都沒有，而您不知道登錄和注冊功能。

感謝您閱讀這么久，如果您有任何建議，請在評論中提出

以上是了解 Spring Security 和 OAuth的詳細內容。更多信息請關注PHP中文網(wǎng)其他相關文章！