【51CTO.com快譯】目前，在大多情況下，尤其是對于企業級應用、或處理敏感數據的應用(如：財務應用)場景中，多因素身份認證(Multi-factor authentication，MFA)已成為了最常見的處理方法。此外，MFA也被相關法律要求在越來越多的行業中是強制執行(尤其是在歐盟)。因此，如果您正在開發應用程序，那么大概率會以某種形式啟用雙(或多)因素身份認證。

在本文中，我將向您展示如何為使用Spring Webflux，來構建的響應式API，以實現兩因素身份認證。該應用主要使用電子郵件和密碼對作為第一安全因素，并采用用戶設備上應用程序(如：Google Authenticator)所生成的一次性代碼(TOTP)作為第二安全因素。

兩因素身份認證是如何工作的

從技術上講，兩(或多)因素身份認證是一個安全過程，用戶必須提供兩個或更多安全因素來讓自己得到認證。也就是說，用戶需要提供除密碼以外的另一個標識符，例如：一次性密碼、硬件令牌、生物特征(如：指紋)等。

該安全過程涉及到如下步驟：

• 用戶輸入電子郵件(用戶名)和密碼。
• 除了第一憑據，用戶還要提交由認證應用生成的一次性代碼。
• 應用程序在對電子郵件(用戶名)和密碼進行身份認證的同時，也使用在注冊過程中頒發的用戶密鑰來認證一次性代碼

由此可見，與使用短信傳遞口令代碼相比，使用諸如Google Authenticator、Microsoft Authenticator、以及FreeOTP等身份認證應用，既能夠避免SIM卡遭受攻擊(請參見--

https://www.theverge.com/2017/6/17/15772142/how-to-set-up-two-factor-authentication)，又能夠無需蜂窩網絡或互聯網連接，進行正常認證。

應用示例

下面，我們將逐步構建一個使用兩因素身份認證技術的簡單REST API。該API要求用戶提供電子郵件密碼對，和由應用生成的短代碼。在此，我使用Android版的Google Authenticator來生成TOTP。其源代碼的github庫鏈接為--

https://github.com/mednikoviurii/spring-twofactor-example。該應用會用到JDK 11、Maven、以及用于存儲用戶個人信息的MongoDB。其項目組織結構如下圖所示：

應用示例的項目結構

在此，我不會遍歷地介紹每一個組成部分，而只會專注于AuthService、TokenManager和TotpManager。這些部分主要負責身份的認證流程。它們分別提供了以下功能：

• AuthService –該組件主要用于存儲、認證和授權所有的業務邏輯，其中包括：注冊、登錄和令牌認證。
• TokenManager–該組件通過抽象代碼，以生成和認證JWT令牌。它能夠使得主要業務邏輯的實現與具體的JWT庫相互獨立。在此，我使用是Nimbus JOSE-JWT(請參見--https://connect2id.com/products/nimbus-jose-jwt/examples)。
• TotpManager–作為另一種抽象，它能夠將實現與基本邏輯相隔離。TotpManager既可被用于生成用戶的密鑰，又可以斷言(assert，可以立即為驗證)給出的短代碼。在此，我使用的是TOTP Java庫(https://github.com/samdjstevens/java-totp)來實現，當然您也可以選用其他的庫。

由于在此僅關注認證組件，因此我們將從用戶的創建過程(注冊)開始，同時涉及到密鑰的生成和令牌的頒發。接著，我們將進入登錄流程，涉及一個由用戶提供的短代碼的斷言。

實現注冊流程

下面，我們將完成一個注冊的過程，其中涉及以下步驟：

• 從客戶端獲取注冊請求。
• 檢查該用戶是否存在。
• 對密碼進行哈希。
• 生成一個密鑰。
• 將用戶存儲到數據庫中。
• 頒發JWT。
• 返回帶有用戶ID、私鑰和令牌的響應。

我將主要的業務邏輯(AuthServiceImpl)與令牌的生成，以及密鑰的產生分離開來。

一般步驟

主要組件AuthServiceImpl會接受SignupRequest，并返回SignupResponse。在后臺，它負責整個注冊的邏輯。下面是具體的實現代碼：

Java

1.  @Override 
2.  public Mono<SignupResponse> signup(SignupRequest request) { 
3.  // generating a new user entity params 
4.  // step 1 
5.  String email = request.getEmail().trim().toLowerCase(); 
6.  String password = request.getPassword(); 
7.  String salt = BCrypt.gensalt(); 
8.  String hash = BCrypt.hashpw(password, salt); 
9.  String secret = totpManager.generateSecret(); 
10. User user = new User(null, email, hash, salt, secret); 
11. // preparing a Mono 
12. Mono<SignupResponse> response = repository.findByEmail(email) 
13.         .defaultIfEmpty(user) // step 2 
14.         .flatMap(result -> { 
15.             // assert, that user does not exist 
16.             // step 3 
17.             if (result.getUserId() == null) { 
18.                 // step 4 
19.                 return repository.save(result).flatMap(result2 -> { 
20.                     // prepare token 
21.                     // step 5 
22.                     String userId = result2.getUserId(); 
23.                     String token = tokenManager.issueToken(userId); 
24.                     SignupResponse signupResponse = new SignupResponse(); 
25.                     signupResponse.setUserId(userId); 
26.                     signupResponse.setSecretKey(secret); 
27.                     signupResponse.setToken(token); 
28.                     signupResponse.setSuccess(true); 
29.                    
30.                     return Mono.just(signupResponse); 
31.                 }); 
32.             } else { 
33.                 // step 6 
34.                 // scenario - user already exists 
35.                 SignupResponse signupResponse = new SignupResponse(); 
36.                 signupResponse.setSuccess(false); 
37.                
38.                 return Mono.just(signupResponse); 
39.             } 
40.         }); 
41. return response; 

下面，讓我們逐步解讀上述實現的過程。在邏輯判讀中：如果當前用戶是新用戶，我們將對其進行注冊;如果該用戶已經存在于數據庫之中，那么我們就必須拒絕該請求。具體步驟為：

• 我們根據請求數據創建一個新的用戶實體，并生成一個相應的密鑰。
• 如果該用戶過去不存在，則將給出的新實體作為其默認實體。
• 檢查存儲庫的調用結果。
• 將用戶保存在數據庫中，并獲取其userId。
• 頒發JWT。
• 如果用戶已經存在，則返回一個拒絕響應。

相比以漏洞和安全問題而聞名的SHA函數，我在此選用jBcrypt庫(請參見-- https://www.mindrot.org/projects/jBCrypt/)，來產生各種安全的哈希和salt(鹽)。如不你不太熟悉jBcrypt的話，請參見教程--

https://dzone.com/articles/password-encryption-and-decryption-using-bcrypt，以獲取更多信息。

生成密鑰

接下來，我們需要實現一個用來生成新的密鑰的函數。它是由TotpManager.generateSecret()內部抽象而來。下面是它的代碼：

Java：

1.  @Override 
2.  public String generateSecret() { 
3.    SecretGenerator generator = new DefaultSecretGenerator(); 
4.    return generator.generate(); 
5.  } 

測試

實現了注冊邏輯之后，我們需要測試它是否能夠按預期進行認證。首先，讓我們調用signup端點以創建一個新的用戶。其結果對象應當包含我們需要添加到應用生成器(如：Google Authenticator)的userId、令牌和密鑰：

成功注冊

不過，我們應當禁止同一封電子郵件兩次進行注冊。在此，我們通過斷言，以保證應用在創建新用戶之前，去檢查現有的電子郵件列表：

登錄響應對象

登錄

下面，我們來討論登錄流程。該流程包括兩個主要部分：認證電子郵件的密碼憑據，以及認證由用戶提供的一次性代碼。和上一節一樣，我們首先介紹登錄所涉及的步驟：

• 從客戶端獲取登錄請求。
• 在數據庫中找到該用戶。
• 使用請求中提供的密碼進行斷言。
• 斷言一次性代碼。
• 返回帶有令牌的登錄響應。

而JWT的生成過程與注冊的過程比較類似。

一般步驟

作為該示例的功能重點，AuthServiceImpl.login將實現主要的業務邏輯。首先，我們需要通過在數據庫中請求電子郵件，來查找用戶;否則，我們需要提供帶有空字段的默認值。也就是說，讓user.getUserId() == null，以表示該用戶并不存在，登錄流程隨即中止。

接著，我們需要斷言密碼的匹配。當我們將密碼的哈希值存儲在數據庫中時，就需要使用存儲的salt對請求中的密碼進行哈希處理，進而斷言這兩個值。

如果密碼匹配，我們需要使用之前存儲的密鑰值來認證提交的代碼。認證成功與否的結果，將在產生JWT和創建LoginResponse對象后得出。以下便是此部分的最終源代碼：

Java

1.  @Override 
2.  public Mono<LoginResponse> login(LoginRequest request) { 
3.    String email = request.getEmail().trim().toLowerCase(); 
4.    String password = request.getPassword(); 
5.    String code = request.getCode(); 
6.    Mono<LoginResponse> response = repository.findByEmail(email) 
7.    // step 1 
8.            .defaultIfEmpty(new User()) 
9.            .flatMap(user -> { 
10.               // step 2 
11.               if (user.getUserId() == null) { 
12.                   // no user 
13.                   LoginResponse loginResponse = new LoginResponse(); 
14.                   loginResponse.setSuccess(false); 
15.                  
16.                   return Mono.just(loginResponse); 
17.               } else { 
18.                   // step 3 
19.                   // user exists 
20.                   String salt = user.getSalt(); 
21.                   String secret = user.getSecretKey(); 
22.                   boolean passwordMatch = BCrypt.hashpw(password, salt).equalsIgnoreCase(user.getHash()); 
23.                  if (passwordMatch) { 
24.                      // step 4 
25.                      // password matched 
26.                      boolean codeMatched = totpManager.validateCode(code, secret); 
27.                      if (codeMatched) { 
28.                          // step 5 
29.                          String token = tokenManager.issueToken(user.getUserId()); 
30.                          LoginResponse loginResponse = new LoginResponse(); 
31.                          loginResponse.setSuccess(true); 
32.                          loginResponse.setToken(token); 
33.                          loginResponse.setUserId(user.getUserId()); 
34.                         
35.                          return Mono.just(loginResponse); 
36.                      } else { 
37.                          LoginResponse loginResponse = new LoginResponse(); 
38.                          loginResponse.setSuccess(false); 
39.                          return Mono.just(loginResponse); 
40.                      } 
41.                  } else { 
42.                      LoginResponse loginResponse = new LoginResponse(); 
43.                      loginResponse.setSuccess(false); 
44.                     
45.                      return Mono.just(loginResponse); 
46.                  } 
47.              } 
48.          }); 
49.  return response; 
50. } 

可見，后臺的邏輯步驟為：

• 提供具有空字段的默認用戶實體。
• 檢查該用戶是否確實存在。
• 從請求和salt處生成密碼的哈希，并存儲在數據庫中。
• 斷言密鑰是否能夠確實匹配。
• 認證一次性代碼，并頒發JWT。

斷言一次性代碼

為了認證由應用生成的一次性代碼，我們必須向TOTP庫提供相應的代碼和密鑰，并將它們保存為用戶實體的一部分。具體代碼如下：

Java

1.  @Override 
2.  public boolean validateCode(String code, String secret) { 
3.    TimeProvider timeProvider = new SystemTimeProvider(); 
4.    CodeGenerator codeGenerator = new DefaultCodeGenerator(); 
5.    CodeVerifier verifier = new DefaultCodeVerifier(codeGenerator, timeProvider); 
6.    return verifier.isValidCode(secret, code); 
7.  } 

測試

最后，我們可以通過測試，以認證登錄的過程是否如期運行。我們將由Google Authenticator生成的代碼作為登錄請求的負載，去調用login端點。

如下圖所示，為了檢查處密碼錯誤的情況，我們需要將進程終止在密碼斷言階段：

由于密碼錯誤，登錄被拒絕

至此，我們已經創建了一個簡單的REST API，它可以通過Spring Webflux(請參見--

https://www.mednikov.tech/two-factor-authentication-for-spring-webflux-apis/)的TOTP來提供兩因素身份認證。如前文所述，為了更專注于身份認證的邏輯，我們省略了所有的其他部分。

如果您對該示例的完整代碼感興趣，請參見--https://github.com/mednikoviurii/spring-twofactor-example。

參考文獻

• Dhiraj Ray的《使用jBCrypt實現密鑰的加、解密》(2017)--https://dzone.com/articles/password-encryption-and-decryption-using-bcrypt。
• Sanjay Patel的《如何在Spring應用中使用Nimbus JOSE和JWT》Natural Programmer Blog(2018)--https://www.naturalprogrammer.com/blog/17852/spring-framework-nimbus-jose-jwt。
• Scott Brady的《使用Nimbus JOSE和JWT創建帶有簽名的JWT》(2019)--https://www.scottbrady91.com/Kotlin/Creating-Signed-JWTs-using-Nimbus-JOSE-JWT。

原標題：Two-Factor Authentication in Spring Webflux REST API ，作者：Yuri Mednikov

【51CTO譯稿，合作站點轉載請注明原文譯者和出處為51CTO.com】