oauth2實現(xiàn)單點登錄

電子書資源見
https://www.yuque.com/docs/share/37bd8227-eece-435a-9805-87254f4b34e9?# 《oauth2授權》

blog 地址 https://youngboy.vip

oauth2是什么？

OAuth2： OAuth2（開放授權）是一個開放標準，允許用戶授權第三方網(wǎng)站訪問他們存儲在另外的服務提供者上的信息，而不需要將用戶名和密碼提供給第三方網(wǎng)站或分享他們數(shù)據(jù)的所有內(nèi)容。

舉個栗子：第三方網(wǎng)站登錄，oschina通過gitee登錄

訪問oschina，點擊登錄可以選擇使用gitee登錄，gitee登錄之后，oschina就能獲取到登錄的gitee賬號相關信息 根據(jù)以上示例，可以將OAuth2分為四個角色：

Resource Owner：資源所有者即上述中的gitee用戶
Resource Server：資源服務器即上述中的gitee服務器，提供gitee用戶基本信息給到第三方應用
Client：第三方應用客戶端即上述中oschina網(wǎng)站
Authorication Server：授權服務器該角色可以理解為管理其余三者關系的中間層
<a name="WlZNm"></a>

四種授權模式的使用場景

模式	適用場景
授權碼模式	適用于網(wǎng)頁第三方授權
密碼模式	適用于手機等客戶端使用
客戶端模式	適用于授權接口給第三方客戶端
簡化模式	適用于web端應用

簡化模式

image.png

客戶端模式

image.png

密碼模式

image.png

授權碼模式

image.png

四種模式的選擇流程

image.png

參考文章 http://www.ruanyifeng.com/blog/2019/04/oauth-grant-types.html
<a name="4HUbK"></a>

常見安全問題

授權碼安全

open redirect 攻擊 Referer 攻擊 redirect_url 控制攻擊

憑證安全

保證client_secret的保密性，不能在日志中輸出client_secret或者用戶的密碼或token
<a name="GQYyl"></a>

csrf攻擊

cross-site request forgery (CSRF)

授權碼模式和簡化模式都應該帶上state參數(shù)，防止可能的csrf攻擊

官方原文6

An opaque value used by the client to maintain state between the request and callback.
The authorization server includes this value when redirecting the user-agent back to the
client. The parameter SHOULD be used for preventing cross-site request forgery (CSRF).

安全建議

客戶端帶上state參數(shù)，登陸頁面接口請求都要加上 CSRF token校驗
日志脫敏，避免泄露憑證或token
全站https并開啟HSTS防止請求劫持
禁止登陸頁面被嵌入iframe
避免在url參數(shù)中傳遞token，游覽器的referrer頭可能會泄露token·
選擇正確的授權模式，手機端游覽器禁止使用簡化模式，前端頁面禁止使用密碼模式（前端不能保存client_secret）
前端后端開啟xss過濾器
access_token有效期不應該大于通常使用時間
使用成熟的oauth2框架

Tips：如果您想對OAuth2.0開放標準進行擴展閱讀，請參看：OAuth標準（英文） | OAuth維基百科（中文） 
<a name="v5NXd"></a>

SSO單點登錄

sso 是什么？

SSO的定義是在多個應用系統(tǒng)中，用戶只需要登錄一次就可以訪問所有相互信任的應用系統(tǒng)。 權限控制主要分兩步

Authentication 認證 (證明自己是自己)
Authorization 授權（證明自己是自己后能夠做什么）

sso 屬于 Authentication 范疇
<a name="6tiZK"></a>

登錄系統(tǒng)

首先，我們要為“登錄”做一個簡要的定義，令后續(xù)的講述更準確。之前的兩篇文章有意無意地混淆了“登錄”與“身份驗證”的說法，因為在本篇之前，不少“傳統(tǒng)Web應用”都將對身份的識別看作整個登錄的過程，很少出現(xiàn)像企業(yè)應用環(huán)境中那樣復雜的情景和需求。但從之前的文章中我們看到，現(xiàn)代Web應用對身份驗證相關的需求已經(jīng)向復雜化發(fā)展了。 我們有必要重新認識一下登錄系統(tǒng)。登錄指的是從識別用戶身份，到允許用戶訪問其權限相應的資源的過程。舉個例子，在網(wǎng)上買好了票之后去影院觀影的過程就是一個典型的登錄過程：我們先去取票機，輸入驗證碼取票；接著拿到票去影廳檢票進入。取票的過程即身份驗證，它能夠證明我們擁有這張票；而后面檢票的過程，則是授權訪問的過程。之所以要分成這兩個過程，最直接的原因還是業(yè)務形態(tài)本身具有復雜性——如果觀景過程是免費匿名的，也就免去了這些過程。 在登錄的過程中，“鑒權”與“授權”是兩個最關鍵的過程。接下來要介紹的一些技術和實踐，也包含在這兩個方面中。雖然現(xiàn)代Web應用的登錄需求比較復雜，但只要處理好了鑒權和授權兩個方面，其余各個方面的問題也將迎刃而解。在現(xiàn)代Web應用的登錄工程實踐中，需要結(jié)合傳統(tǒng)Web應用的典型實踐，以及一些新的思路，才能既解決好登錄需求，又能符合Web的輕量級架構思路。

解析常見的登錄場景

在簡單的Web系統(tǒng)中，典型的鑒權也就是要求用戶輸入并比對用戶名和密碼的過程，而授權則是確保會話Cookie存在。而在稍微復雜的Web系統(tǒng)中，則需要考慮多種鑒權方式，以及多種授權場景。上一篇文章中所述的“多種登錄方式”和“雙因子鑒權”就是多種鑒權方式的例子。有經(jīng)驗的人經(jīng)常調(diào)侃說，只要理解了鑒權與授權，就能清晰地理解登錄系統(tǒng)了。不光如此，這也是安全登錄系統(tǒng)的基礎所在。 鑒權的形式豐富多彩，有傳統(tǒng)的用戶名密碼對、客戶端證書，有人們越來越熟悉的第三方登錄、手機驗證，以及新興的掃碼和指紋等方式，它們都能用于對用戶的身份進行識別。在成功識別用戶之后，在用戶訪問資源或執(zhí)行操作之前，我們還需要對用戶的操作進行授權。 在一些特別簡單的情形中——用戶一經(jīng)識別，就可以無限制地訪問資源、執(zhí)行所有操作——系統(tǒng)直接對所有“已登錄的人”放行。比如高速公路收費站，只要車輛有合法的號牌即可放行，不需要給駕駛員發(fā)一張用于指示“允許行駛的方向或時間”的票據(jù)。除了這類特別簡單的情形之外，授權更多時候是比較復雜的工作。 在單一的傳統(tǒng)Web應用中，授權的過程通常由會話Cookie來完成——只要服務器發(fā)現(xiàn)瀏覽器攜帶了對應的Cookie，即允許用戶訪問資源、執(zhí)行操作。而在瀏覽器之外，例如在Web API調(diào)用、移動應用和富 Web 應用等場景中，要提供安全又不失靈活的授權方式，就需要借助令牌技術。

令牌

令牌是一個在各種介紹登錄技術的文章中常被提及的概念，也是現(xiàn)代Web應用系統(tǒng)中非常關鍵的技術。令牌是一個非常簡單的概念，它指的是在用戶通過身份驗證之后，為用戶分配的一個臨時憑證。在系統(tǒng)內(nèi)部，各個子系統(tǒng)只需要以統(tǒng)一的方式正確識別和處理這個憑證即可完成對用戶的訪問和操作進行授權。在上文所提到的例子中，電影票就是一個典型的令牌。影廳門口的工作人員只需要確認來客手持印有對應場次的電影票即視為合法訪問，而不需要理會客戶是從何種渠道取得了電影票（比如自行購買、朋友贈予等），電影票在本場次范圍內(nèi)可以持續(xù)使用（比如可以中場出去休息等）、過期作廢。通過電影票這樣一個簡單的令牌機制，電影票的出售渠道可以豐富多樣，檢票人員的工作卻仍然簡單輕松。

OAuth 2、Open ID Connect

令牌在廣為使用的OAuth技術中被采用來完成授權的過程。OAuth是一種開放的授權模型，它規(guī)定了一種供資源擁有方與消費方之間簡單又直觀的交互方法，即從消費方向資源擁有方發(fā)起使用AccessToken（訪問令牌）簽名的HTTP請求。這種方式讓消費方應用在無需（也無法）獲得用戶憑據(jù)的情況下，只要用戶完成鑒權過程并同意消費方以自己的身份調(diào)用數(shù)據(jù)和操作，消費方就可以獲得能夠完成功能的訪問令牌。OAuth簡單的流程和自由的編程模型讓它很好地滿足了開放平臺場景中授權第三方應用使用用戶數(shù)據(jù)的需求。不少互聯(lián)網(wǎng)公司建設開放平臺，將它們的用戶在其平臺上的數(shù)據(jù)以 API 的形式開放給第三方應用來使用，從而讓用戶享受更豐富的服務。 OAuth在各個開放平臺的成功使用，令更多開發(fā)者了解到它，并被它簡單明確的流程所吸引。此外，OAuth協(xié)議規(guī)定的是授權模型，并不規(guī)定訪問令牌的數(shù)據(jù)格式，也不限制在整個登錄過程中需要使用的鑒權方法。人們很快發(fā)現(xiàn)，只要對OAuth進行合適的利用即可將其用于各種自有系統(tǒng)中的場景。例如，將 Web 服務視作資源擁有方，而將富Web應用或者移動應用視作消費方應用，就與開放平臺的場景完全吻合。 另一個大量實踐的場景是基于OAuth的單點登錄。OAuth并沒有對鑒權的部分做規(guī)定，也不要求在握手交互過程中包含用戶的身份信息，因此它并不適合作為單點登錄系統(tǒng)來使用。然而，由于OAuth的流程中隱含了鑒權的步驟，因而仍然有不少開發(fā)者將這一鑒權的步驟用作單點登錄系統(tǒng)，這也儼然衍生成為一種實踐模式。更有人將這個實踐進行了標準化，它就是Open ID Connect——基于OAuth的身份上下文協(xié)議，通過它即可以JWT的形式安全地在多個應用中共享用戶身份。接下來，只要讓鑒權服務器支持較長的會話時間，就可以利用OAuth為多個業(yè)務系統(tǒng)提供單點登錄功能了。 我們還沒有討論OAuth對鑒權系統(tǒng)的影響。實際上，OAuth對鑒權系統(tǒng)沒有影響，在它的框架內(nèi)，只是假設已經(jīng)存在了一種可用于識別用戶的有效機制，而這種機制具體是怎么工作的，OAuth并不關心。因此我們既可以使用用戶名密碼（大多數(shù)開放平臺提供商都是這種方式），也可以使用掃碼登錄來識別用戶，更可以提供諸如“記住密碼”，或者雙因子驗證等其他功能。

匯總

上面羅列了大量術語和解釋，那么具體到一個典型的Web系統(tǒng)中，又應該如何對安全系統(tǒng)進行設計呢？綜合這些技術，從端到云，從Web門戶到內(nèi)部服務，本文給出如下架構方案建議： 推薦為整個應用的所有系統(tǒng)、子系統(tǒng)都部署全程的HTTPS，如果出于性能和成本考慮做不到，那么至少要保證在用戶或設備直接訪問的Web應用中全程使用HTTPS。 用不同的系統(tǒng)分別用作身份和登錄，以及業(yè)務服務。當用戶登錄成功之后，使用OpenID Connect向業(yè)務系統(tǒng)頒發(fā)JWT格式的訪問令牌和身份信息。如果需要，登錄系統(tǒng)可以提供多種登錄方式，或者雙因子登錄等增強功能。作為安全令牌服務（STS），它還負責頒發(fā)、刷新、驗證和取消令牌的操作。在身份驗證的整個流程的每一個步驟，都使用OAuth及JWT中內(nèi)置的機制來驗證數(shù)據(jù)的來源方是可信的：登錄系統(tǒng)要確保登錄請求來自受認可的業(yè)務應用，而業(yè)務在獲得令牌之后也需要驗證令牌的有效性。 在Web頁面應用中，應該申請時效較短的令牌。將獲取到的令牌向客戶端頁面中以httponly的方式寫入會話Cookie，以用于后續(xù)請求的授權；在后緒請求到達時，驗證請求中所攜帶的令牌，并延長其時效?；贘WT自包含的特性，輔以完備的簽名認證，Web 應用無需額外地維護會話狀態(tài)。 在富客戶端Web應用（單頁應用），或者移動端、客戶端應用中，可按照應用業(yè)務形態(tài)申請時效較長的令牌，或者用較短時效的令牌、配合專用的刷新令牌使用。 在Web應用的子系統(tǒng)之間，調(diào)用其他子服務時，可靈活使用“應用程序身份”（如果該服務完全不直接對用戶提供調(diào)用），或者將用戶傳入的令牌直接傳遞到受調(diào)用的服務，以這種方式進行授權。各個業(yè)務系統(tǒng)可結(jié)合基于角色的訪問控制（RBAC）開發(fā)自有專用權限系統(tǒng)。 http://insights.thoughtworkers.org/traditional-web-app-authentication/
<a name="axw0U"></a>

各大開發(fā)平臺oauth2的使用

qq開發(fā)平臺 https://wiki.open.qq.com/wiki/website/OAuth2.0%E7%AE%80%E4%BB%8B
gitee平臺 https://gitee.com/api/v5/oauth_doc#/
微信平臺 https://developers.weixin.qq.com/doc/offiaccount/OA_Web_Apps/Wechat_webpage_authorization.html
<a name="bCLBa"></a>

cas 解決方案

cas 是一種協(xié)議，cas server 是開源的實現(xiàn)

官網(wǎng)地址 https://www.apereo.org/projects/cas
<a name="Y6Vq0"></a>

cas 協(xié)議

CAS協(xié)議是一種簡單且功能強大的基于票證(ticket)的協(xié)議。它涉及一個或多個客戶端和一臺服務器。中央身份驗證服務（CAS）是Web的單點登錄/單點退出協(xié)議。用戶向中央CAS Server應用程序提供一次憑據(jù)（例如用戶ID和密碼），就可以訪問多個應用程序。客戶端嵌入在CASified應用程序中（稱為“ CAS服務”），而CAS服務器是獨立組件：

CAS服務器負責驗證用戶并授予訪問應用程序
CAS客戶保護CAS應用程序和檢索CAS服務器的授權用戶的身份。

關鍵概念:

TGT存儲在TGCcookie中的（“票證授予票證”）代表用戶的SSO會話。
ST（服務票據(jù)），作為傳輸GET參數(shù)的URL，代表由CAS服務器授予訪問CASified應用程序?qū)μ囟ㄓ脩簟?/li>

官方地址 https://www.apereo.org/projects/cas 流程參考 https://blog.csdn.net/isyoungboy/article/details/103242009[圖片上傳失敗...(image-d12fde-1602203995839)]
<a name="Sstz5"></a>

cas server

cas server 不僅僅是對cas協(xié)議的實現(xiàn)，cas server 還實現(xiàn)了 oidc smal 等協(xié)議
<a name="c0P7Q"></a>

部署要求

java版本要求jdk11以上
<a name="eubQf"></a>

優(yōu)點

功能豐富，支持多種認證協(xié)議實現(xiàn) cas oidc smal
支持協(xié)議代理使用pac4j實現(xiàn)
客戶端支持齊全，支持spring security spring boot
官方文檔比較全
<a name="gWuaN"></a>

缺點

如果使用cas協(xié)議，對已有系統(tǒng)改動比較大，改動成本高
框架比較復雜
java版本要求高
<a name="OziOJ"></a>

keycloak 解決方案

Keycloak 是一個為瀏覽器和 RESTful Web 服務提供 SSO 的集成?；贠IDC規(guī)范。最開始是面向 JBoss 和 Wildfly 通訊 源碼地址是：https://github.com/keycloak/keycloak/
<a name="6MWhJ"></a>

部署要求

java8
<a name="ZPzFD"></a>

優(yōu)點

支持ladp等中間件
功能豐富，有多種認證協(xié)議實現(xiàn) cas oidc smal
自帶有完善的用戶角色組織管理系統(tǒng)，同時還有自帶的web控制臺管理用戶角色組織客戶端等信息
客戶端支持齊全，支持spring security spring boot
<a name="2czN9"></a>

缺點

改動成本高
中間件比較復雜
已有用戶體系的系統(tǒng)不好改造
文檔不多，沒有很多人使用
<a name="BwavC"></a>

spring security oauth2 解決方案

oauth2 只是授權協(xié)議并不包含完整的認證協(xié)議，需要在oauth2的基礎上進行改造才能使用，需要寫一些代碼，亦可以使用oidc協(xié)議可以簡單理解為（openid + oauth2），改動后以前的前端登陸實現(xiàn)都需要從項目中遷移出來到用戶認證中心，用戶統(tǒng)一到認證中心登陸（和qq github 等平臺一樣，上面的解決方案也差不多）
<a name="33Elk"></a>

優(yōu)點

可以靈活添加功能改動成本較小如果使用oidc協(xié)議，接入方可以選擇標準的開源成熟的 oidc sdk，不需要再自己寫sdk
<a name="8pe7C"></a>

缺點

需要拓展一些功能(可以參考cas中的實現(xiàn))
<a name="HIGF0"></a>

oauth2 sso 簡單認證流程

代號	描述
UAA	認證中心
A	系統(tǒng)A
B	系統(tǒng)B
USER	用戶

第一次訪問A系統(tǒng)

[圖片上傳失敗...(image-586f67-1602203995839)]> 訪問A系統(tǒng)之后再訪問B系統(tǒng)

[圖片上傳失敗...(image-68bba7-1602203995839)]

現(xiàn)有用戶體系問題

Q: 接入方系統(tǒng)以有現(xiàn)成的用戶怎么解決？

A：接入方自己解決（接入方可以通過綁定已有用戶，也可以新建用戶）
<a name="adTlL"></a>

權限控制問題

Q: 接入方系統(tǒng)有現(xiàn)成的用戶權限怎么控制？

A: 單點登陸只管認證的問題，不需要考慮接入方的權限怎么控制

Q: 接入方系統(tǒng)怎么控制權限？

A: 使用用戶詳情接口獲取用戶詳細信息，使用client的scope 或者 authorities

Q: 接入方系統(tǒng)與接入方系統(tǒng)間需要相互調(diào)用嗎？

A: 不需要相互調(diào)用

單系統(tǒng)登出功能，全局登出功能

“SSO” 是指單點登錄。
“SLO” 是指單一注銷。

目前系統(tǒng)只實現(xiàn)了全局登出，參考了oidc使用前端游覽器通知第三方退出的方法

登出流程 
<a name="DQZe2"></a>

參考鏈接

open id 官網(wǎng) https://openid.net/connect/ oidc 文檔 https://openid.net/specs/openid-connect-core-1_0.html oidc core 協(xié)議 https://www.cnblogs.com/linianhui/p/openid-connect-core.html oidc 認證流程 http://www.sohu.com/a/206818578_468635 
<a name="rtbHT"></a>

基于spring security oauth2單點登錄的實現(xiàn)

實現(xiàn)功能點

用戶認證（用戶名密碼，釘釘掃碼）
跨域名單點登錄
統(tǒng)一登出（參考了oidc實現(xiàn)）
客戶端token獲取
password模式token獲取
簡化模式token獲取

spring security oauth2配置項

配置授權服務

@EnableAuthorizationServer @Configuration public class OAuth2ServerConfiguration extends AuthorizationServerConfigurerAdapter { @Autowired private UaaProperties uaaProperties; @Autowired private ApplicationContext applicationContext; @Autowired private RemoteClientDetailsService remoteClientDetailsService; @Autowired private RedisTokenStoreEnhance redisTokenStoreEnhance; @Autowired private AuthorizationCodeServices authorizationCodeServices; @Override public void configure(ClientDetailsServiceConfigurer clients) throws Exception { clients.withClientDetails(remoteClientDetailsService);//配置客戶端詳情服務 } @Override public void configure(AuthorizationServerSecurityConfigurer oauthServer) throws Exception { //設置token的訪問權限為permitAll 檢查token 的權限為 isAuthenticated() 在httpSecurity 中配置權限是沒用的 oauthServer .tokenKeyAccess("permitAll()")//設置oauth/token_key 的訪問權限 .checkTokenAccess("isAuthenticated()") //設置checkToken 接口的訪問權限 .allowFormAuthenticationForClients();//設置允許Client通過Form認證，否則就只能使用basic認證，from認證相關過濾器為 ClientCredentialsTokenEndpointFilter } @Override public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception { //配置token處理鏈 Collection<TokenEnhancer> tokenEnhancers = applicationContext.getBeansOfType(TokenEnhancer.class).values(); TokenEnhancerChain tokenEnhancerChain = new TokenEnhancerChain(); tokenEnhancerChain.setTokenEnhancers(new ArrayList<>(tokenEnhancers)); //配置自定義授權碼服務 endpoints.authorizationCodeServices(authorizationCodeServices); endpoints .tokenStore(tokenStore())//配置token儲存 .tokenEnhancer(tokenEnhancerChain)//配置token處理鏈 .reuseRefreshTokens(false) //設置自定義的oauth2異常處理器 .exceptionTranslator(new OAuth2ResponseExceptionTranslator()); //don't reuse or we will run into session inactivity timeouts } //把token轉(zhuǎn)換為jwttoken的轉(zhuǎn)換器 @Bean public JwtAccessTokenConverter jwtAccessTokenConverter() { JwtAccessTokenConverter converter = new VerificationCode.RedisTokenConverter(redisTokenStoreEnhance); KeyPair keyPair = new KeyStoreKeyFactory( new ClassPathResource(uaaProperties.getKeyStore().getName()), uaaProperties.getKeyStore().getPassword().toCharArray()) .getKeyPair(uaaProperties.getKeyStore().getAlias()); converter.setKeyPair(keyPair); return converter; } @Bean public JwtTokenStore tokenStore() { return new JwtTokenStore(jwtAccessTokenConverter()); } } 
<a name="zzZT4"></a>

spring security oauth2 拓展項

定制用戶確認授權頁面

@Bean public TokenStoreUserApprovalPlusHandler tokenStoreUserApprovalPlusHandler(TokenStore tokenStore, ClientDetailsService clientDetailsService, AuthorizationEndpoint authorizationEndpoint){ TokenStoreUserApprovalPlusHandler approvalHandler = new TokenStoreUserApprovalPlusHandler(); approvalHandler.setTokenStore(tokenStore); approvalHandler.setClientDetailsService(clientDetailsService); approvalHandler.setRequestFactory(new DefaultOAuth2RequestFactory(clientDetailsService)); authorizationEndpoint.setUserApprovalHandler(approvalHandler); authorizationEndpoint.setUserApprovalPage("access");//設置授權頁面為access return approvalHandler; } 
<a name="FYBFb"></a>

定制授權碼生成服務實現(xiàn)

@Component public class RedisAuthorizationCodeServices extends RandomValueAuthorizationCodeServices { @Autowired private RedisTemplate redisTemplate; /** * 存儲code到redis，并設置過期時間，10分鐘
 * value為OAuth2Authentication序列化后的字節(jié)
 * 因為OAuth2Authentication沒有無參構造函數(shù)
 * redisTemplate.opsForValue().set(key, value, timeout, unit); * 這種方式直接存儲的話，redisTemplate.opsForValue().get(key)的時候有些問題， * 所以這里采用最底層的方式存儲，get的時候也用最底層的方式獲取 */ @Override protected void store(String code, OAuth2Authentication authentication) { redisTemplate.opsForValue().set(codeKey(code), authentication,10, TimeUnit.MINUTES); } @Override protected OAuth2Authentication remove(String code) { try{ return (OAuth2Authentication) redisTemplate.opsForValue().get(codeKey(code)); }catch (Exception e){ CodeAuthDTO codeAuthDTO = (CodeAuthDTO) redisTemplate.opsForValue().get(codeKey(code)); Set<SimpleGrantedAuthority> auths = codeAuthDTO.getAuths().stream().map(a -> new SimpleGrantedAuthority(a)).collect(Collectors.toSet()); OAuth2Request oAuth2Request = new OAuth2Request(codeAuthDTO.getRequestParameters(), codeAuthDTO.getClientId(), convertAuth(codeAuthDTO.getClientAuths()), codeAuthDTO.isApproved(), codeAuthDTO.getScope(), codeAuthDTO.getResourceIds(), codeAuthDTO.getRedirectUri(), codeAuthDTO.getResponseTypes(), codeAuthDTO.getExtensions()); return new OAuth2Authentication(oAuth2Request,new UsernamePasswordAuthenticationToken(codeAuthDTO.getPrincipal(),codeAuthDTO.getCredentials(),auths)); } } public Set<SimpleGrantedAuthority> convertAuth(Set<String> auths){ return auths.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toSet()); } public Set<String> convertStr(Collection<? extends GrantedAuthority> auths){ return auths.stream().map(GrantedAuthority::getAuthority).collect(Collectors.toSet()); } private String codeKey(String code) { return "oauth2:codes:" + code; } } 
<a name="ym9ZF"></a>

定制登出處理器(統(tǒng)一登出)

@Component public class DefaultSSOLogoutSuccessHandler implements SSOLogoutSuccessHandler { @Autowired private RedisTokenStoreEnhance redisTokenStoreEnhance; @Autowired private ClientDetailsService clientDetailsService; @Override public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication, Model model) { //查詢當前用戶登錄的客戶端 Object principal = authentication.getPrincipal(); if(principal instanceof SystemUser){ String userName = ((SystemUser) principal).getUsername(); //通過用戶登錄名查詢在線的客戶端 Set<TokenAndClientId> clients = redisTokenStoreEnhance.findTokenAndClientIdByUserName(userName); //構建登出地址 if(!CollectionUtils.isEmpty(clients)){ Set<String> tokens = Sets.newLinkedHashSet(); Set<String> logoutUrls = Sets.newHashSet(); for (TokenAndClientId client : clients) { String clientId = client.getClientId(); String token = client.getToken(); //記錄要注銷的token tokens.add(token); ClientDetails clientDetails = clientDetailsService.loadClientByClientId(clientId); Map<String, Object> additionalInformation = clientDetails.getAdditionalInformation(); //獲取客戶端配置的登出地址 String logoutUrl = (String) additionalInformation.get("logoutUrl"); if(StringUtils.hasText(logoutUrl)){ //拼接客戶端的退出url，參數(shù)為access_token logoutUrls.add(resolveLogoutUrl(logoutUrl,token)); } } model.addAttribute("logoutUrls",logoutUrls); //清空所有的授權token redisTokenStoreEnhance.deleteUserAccessKey(userName,tokens); } } } public String resolveLogoutUrl(String logoutUrl,String token){ UriComponentsBuilder template = UriComponentsBuilder.fromUriString(logoutUrl); template.queryParam("access_token",token); return template.build().toUriString(); } }
<a name="Ey7eD"></a>

定制用戶同意拒絕處理器

public class TokenStoreUserApprovalPlusHandler extends TokenStoreUserApprovalHandler { private String scopePrefix = OAuth2Utils.SCOPE_PREFIX; private ClientDetailsService clientDetailsService; @Override public Map<String, Object> getUserApprovalRequest(AuthorizationRequest authorizationRequest, Authentication userAuthentication) { Map<String, Object> userApprovalRequest = super.getUserApprovalRequest(authorizationRequest, userAuthentication); String clientId = authorizationRequest.getClientId(); ClientDetails clientDetails = clientDetailsService.loadClientByClientId(clientId); userApprovalRequest.put("clientName",clientDetails.getAdditionalInformation().getOrDefault("clientName","未知客戶端")); userApprovalRequest.put("iconUrl",clientDetails.getAdditionalInformation().getOrDefault("iconUrl","未知客戶端")); String scope = (String) userApprovalRequest.getOrDefault("scope","user_info"); if(scope.indexOf(" ")==-1){ Constants.SCOPE_INFOS.stream().findFirst().filter(s->s.getName().equals(scope)).ifPresent(scopeInfo -> userApprovalRequest.put("scope_info", JSON.toJSONString(Arrays.asList(scopeInfo)))); }else { List<ScopeInfo> scopeInfos = Arrays.stream(scope.split(" ")) .map(scopeInfo -> Constants.SCOPE_INFOS.stream().filter(s -> s.getName().equals(scopeInfo)).findAny().orElse(null)) .filter(i -> i != null) .collect(Collectors.toList()); userApprovalRequest.put("scope_info", JSON.toJSONString(scopeInfos)); } return userApprovalRequest; } @Override public void setClientDetailsService(ClientDetailsService clientDetailsService) { super.setClientDetailsService(clientDetailsService); this.clientDetailsService = clientDetailsService; } @Override public AuthorizationRequest updateAfterApproval(AuthorizationRequest authorizationRequest, Authentication userAuthentication) { // Get the approved scopes Set<String> requestedScopes = authorizationRequest.getScope(); Set<String> approvedScopes = new HashSet<String>(); Set<Approval> approvals = new HashSet<Approval>(); Date expiry = computeExpiry(); // Store the scopes that have been approved / denied Map<String, String> approvalParameters = authorizationRequest.getApprovalParameters(); for (String requestedScope : requestedScopes) { String approvalParameter = scopePrefix + requestedScope; String value = approvalParameters.get(approvalParameter); value = value == null ? "" : value.toLowerCase(); if ("true".equals(value) || value.startsWith("approve")) { approvedScopes.add(requestedScope); approvals.add(new Approval(userAuthentication.getName(), authorizationRequest.getClientId(), requestedScope, expiry, Approval.ApprovalStatus.APPROVED)); } else { approvals.add(new Approval(userAuthentication.getName(), authorizationRequest.getClientId(), requestedScope, expiry, Approval.ApprovalStatus.DENIED)); } } boolean approved; authorizationRequest.setScope(approvedScopes); if (approvedScopes.isEmpty() && !requestedScopes.isEmpty()) { approved = false; } else { approved = true; } authorizationRequest.setApproved(approved); return authorizationRequest; } private Date computeExpiry() { Calendar expiresAt = Calendar.getInstance(); expiresAt.add(Calendar.MONTH, 1); return expiresAt.getTime(); } }
<a name="FTzoi"></a>

定制認證授權入口

package com.ecidi.uaa.security; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.InitializingBean; import org.springframework.security.core.AuthenticationException; import org.springframework.security.web.; import org.springframework.security.web.util.RedirectUrlBuilder; import org.springframework.security.web.util.UrlUtils; import org.springframework.util.Assert; import org.springframework.util.StringUtils; import javax.servlet.RequestDispatcher; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; @Slf4j public class OAuth2PlusAuthenticationEntryPoint implements AuthenticationEntryPoint , InitializingBean { private PortMapper portMapper = new PortMapperImpl(); private PortResolver portResolver = new PortResolverImpl(); private String loginFormUrl; private boolean forceHttps = false; private boolean useForward = false; private final RedirectStrategy redirectStrategy = new DefaultRedirectStrategy(); public OAuth2PlusAuthenticationEntryPoint(String loginFormUrl) { Assert.notNull(loginFormUrl, "loginFormUrl cannot be null"); this.loginFormUrl = loginFormUrl; } public void afterPropertiesSet() { Assert.isTrue( StringUtils.hasText(loginFormUrl) && UrlUtils.isValidRedirectUrl(loginFormUrl), "loginFormUrl must be specified and must be a valid redirect URL"); if (useForward && UrlUtils.isAbsoluteUrl(loginFormUrl)) { throw new IllegalArgumentException( "useForward must be false if using an absolute loginFormURL"); } Assert.notNull(portMapper, "portMapper must be specified"); Assert.notNull(portResolver, "portResolver must be specified"); } protected String determineUrlToUseForThisRequest(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) { return getLoginFormUrl(); } public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException { String redirectUrl = null; if (useForward) { if (forceHttps && "http".equals(request.getScheme())) { // First redirect the current request to HTTPS. // When that request is received, the forward to the login page will be // used. redirectUrl = buildHttpsRedirectUrlForRequest(request); } if (redirectUrl == null) { String loginForm = determineUrlToUseForThisRequest(request, response, authException); if (log.isDebugEnabled()) { log.debug("Server side forward to: " + loginForm); } RequestDispatcher dispatcher = request.getRequestDispatcher(loginForm); dispatcher.forward(request, response); return; } } else { redirectUrl = buildRedirectUrlToLoginPage(request, response, authException); } redirectStrategy.sendRedirect(request, response, redirectUrl); } protected String buildRedirectUrlToLoginPage(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) { String loginForm = determineUrlToUseForThisRequest(request, response, authException); if (UrlUtils.isAbsoluteUrl(loginForm)) { return loginForm; } int serverPort = portResolver.getServerPort(request); String scheme = request.getScheme(); RedirectUrlBuilder urlBuilder = new RedirectUrlBuilder(); urlBuilder.setScheme(scheme); urlBuilder.setServerName(request.getServerName()); urlBuilder.setPort(serverPort); urlBuilder.setContextPath(request.getContextPath()); urlBuilder.setPathInfo(loginForm); if (forceHttps && "http".equals(scheme)) { Integer httpsPort = portMapper.lookupHttpsPort(serverPort); if (httpsPort != null) { // Overwrite scheme and port in the redirect URL urlBuilder.setScheme("https"); urlBuilder.setPort(httpsPort); } else { log.warn("Unable to redirect to HTTPS as no port mapping found for HTTP port " + serverPort); } } return urlBuilder.getUrl(); } /* * Builds a URL to redirect the supplied request to HTTPS. Used to redirect the * current request to HTTPS, before doing a forward to the login page. */ protected String buildHttpsRedirectUrlForRequest(HttpServletRequest request) { int serverPort = portResolver.getServerPort(request); Integer httpsPort = portMapper.lookupHttpsPort(serverPort); if (httpsPort != null) { RedirectUrlBuilder urlBuilder = new RedirectUrlBuilder(); urlBuilder.setScheme("https"); urlBuilder.setServerName(request.getServerName()); urlBuilder.setPort(httpsPort); urlBuilder.setContextPath(request.getContextPath()); urlBuilder.setServletPath(request.getServletPath()); urlBuilder.setPathInfo(request.getPathInfo()); urlBuilder.setQuery(request.getQueryString()); return urlBuilder.getUrl(); } // Fall through to server-side forward with warning message log.warn("Unable to redirect to HTTPS as no port mapping found for HTTP port " + serverPort); return null; } public void setForceHttps(boolean forceHttps) { this.forceHttps = forceHttps; } protected boolean isForceHttps() { return forceHttps; } public String getLoginFormUrl() { return loginFormUrl; } public void setPortMapper(PortMapper portMapper) { Assert.notNull(portMapper, "portMapper cannot be null"); this.portMapper = portMapper; } protected PortMapper getPortMapper() { return portMapper; } public void setPortResolver(PortResolver portResolver) { Assert.notNull(portResolver, "portResolver cannot be null"); this.portResolver = portResolver; } protected PortResolver getPortResolver() { return portResolver; } public void setUseForward(boolean useForward) { this.useForward = useForward; } protected boolean isUseForward() { return useForward; } } 
<a name="IZ1ms"></a>

定制用戶認證過濾器

public class UsernamePasswordPlusAuthenticationFilter extends AbstractAuthenticationProcessingFilter { /* * 認證類型用戶名密碼認證釘釘掃碼認證 / public static final String AUTH_TYPE = "encrypt_key"; private static final String PASSWORD_AUTH = "password"; private static final String DING_AUTH = "ding"; public static final String SPRING_SECURITY_FORM_USERNAME_KEY = "user[login]"; public static final String SPRING_SECURITY_FORM_PASSWORD_KEY = "encrypt_data[password]"; public static final String CODE_KEY = "code"; public static final String NOISE_KEY = "noise"; private String privateKey = "xxx"; private String authType = AUTH_TYPE; private String usernameParameter = SPRING_SECURITY_FORM_USERNAME_KEY; private String passwordParameter = SPRING_SECURITY_FORM_PASSWORD_KEY; private String codeParameter = CODE_KEY; private String noiseParameter = NOISE_KEY; private boolean postOnly = true; private VerificationCode verificationCode; public UsernamePasswordPlusAuthenticationFilter(AntPathRequestMatcher antPathRequestMatcher,VerificationCode verificationCode) { super(antPathRequestMatcher); this.verificationCode=verificationCode; } public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException { if (postOnly && !request.getMethod().equals("POST")) { throw new AuthenticationServiceException( "Authentication method not supported: " + request.getMethod()); } String authType = obtainAuthType(request); AbstractAuthenticationToken authRequest = null; if(PASSWORD_AUTH.equals(authType)){ //用戶名密碼認證 preCheckCode(request); String username = obtainUsername(request); String credentials = obtainPassword(request); if (username == null) { username = ""; } if (credentials == null) { credentials = ""; } username = username.trim(); //驗證碼校驗加在哪比較合適？加載過濾器這行注釋之前比較合適，這樣驗證碼錯誤不用每次都解密一遍密碼 String decrcyptData = RSAUtils.decryptDataOnJava(credentials, privateKey); String separator = (String) request.getSession().getAttribute("separator"); String cleanSeparator = separator.replace(" $", "\\$ "); String[] split = decrcyptData.split(cleanSeparator); String csrf_token = split[0];//這里可以再校驗一次csrf_token，不過能進到這里說明已經(jīng)通過csrf校驗了 String password= split[1]; authRequest = new UsernamePasswordAuthenticationToken( username, password); // Allow subclasses to set the "details" property setDetails(request, authRequest); } return this.getAuthenticationManager().authenticate(authRequest); } / * 校驗驗證碼 * @param request 請求對象 */ private void preCheckCode(HttpServletRequest request) { String code = obtainCode(request); String noise = obtainNoise(request); verificationCode.verifyCode(noise,code); } @Nullable protected String obtainPassword(HttpServletRequest request) { return request.getParameter(passwordParameter); } @Nullable protected String obtainCode(HttpServletRequest request) { return request.getParameter(codeParameter); } @Nullable protected String obtainNoise(HttpServletRequest request) { return request.getParameter(noiseParameter); } @Nullable protected String obtainAuthType(HttpServletRequest request) { return request.getParameter(authType); } @Nullable protected String obtainUsername(HttpServletRequest request) { return request.getParameter(usernameParameter); } protected void setDetails(HttpServletRequest request, AbstractAuthenticationToken authRequest) { authRequest.setDetails(authenticationDetailsSource.buildDetails(request)); } public void setUsernameParameter(String usernameParameter) { Assert.hasText(usernameParameter, "Username parameter must not be empty or null"); this.usernameParameter = usernameParameter; } public void setPasswordParameter(String passwordParameter) { Assert.hasText(passwordParameter, "Password parameter must not be empty or null"); this.passwordParameter = passwordParameter; } public void setPostOnly(boolean postOnly) { this.postOnly = postOnly; } public final String getUsernameParameter() { return usernameParameter; } public final String getPasswordParameter() { return passwordParameter; } }
<a name="02gOX"></a>

定制登錄頁面，授權頁面

@Override protected void configure(HttpSecurity http) throws Exception { http.exceptionHandling() .authenticationEntryPoint(new OAuth2PlusAuthenticationEntryPoint(LOGIN_PAGE)) //指定登錄頁 .accessDeniedHandler(new OAuth2AccessDeniedHandler()) .accessDeniedPage("/403") .and() .authorizeRequests() .antMatchers("/asserts/**").permitAll() .antMatchers("/oauth/token").permitAll() .antMatchers("/oauth/authorize").permitAll() .antMatchers("/code").permitAll() .antMatchers("/login2").permitAll() .antMatchers("/loginpage").permitAll() .antMatchers("/userprofile").access("#oauth2.hasScope('user_info')") .anyRequest().authenticated() .and().sessionManagement().sessionAuthenticationErrorUrl(LOGIN_PAGE);//指定登錄頁 addUsernamePasswordPlusAuthenticationFilter(http); } @Bean public TokenStoreUserApprovalPlusHandler tokenStoreUserApprovalPlusHandler(TokenStore tokenStore, ClientDetailsService clientDetailsService, AuthorizationEndpoint authorizationEndpoint){ TokenStoreUserApprovalPlusHandler approvalHandler = new TokenStoreUserApprovalPlusHandler(); approvalHandler.setTokenStore(tokenStore); approvalHandler.setClientDetailsService(clientDetailsService); approvalHandler.setRequestFactory(new DefaultOAuth2RequestFactory(clientDetailsService)); authorizationEndpoint.setUserApprovalHandler(approvalHandler); authorizationEndpoint.setUserApprovalPage("access");//設置授權頁 return approvalHandler; } 
<a name="G4hgZ"></a>

oauth2權限控制

客戶端模式接口權限控制

通過客戶端模式獲取的token沒有用戶信息，只有client的信息，client 可以通過 scope 字段控制權限，也可以通過自authority字段控制權限（權限用逗號隔開）

客戶端信息存儲表為 oauth_client_details

通過scope控制權限 oauth2表達式參考：org.springframework.security.oauth2.provider.expression.OAuth2SecurityExpressionMethods .antMatchers("/userprofile").access("#oauth2.hasScope('user_info')") .antMatchers("/userprofile").access("#oauth2.clientHasRole('ROLE_USER')")//判斷是否有權限，spring security中role本質(zhì)就是權限 oauth2權限表達式拓展類參考 org.springframework.security.oauth2.provider.expression.OAuth2WebSecurityExpressionHandler
<a name="fQ9jW"></a>

用戶接口權限控制

普通表達式參考：org.springframework.security.access.expression.SecurityExpressionOperations .antMatchers("/asserts/**").permitAll() .antMatchers("/oauth/token").permitAll() .antMatchers("/oauth/authorize").permitAll() 
<a name="8lGx8"></a>

網(wǎng)關統(tǒng)一鑒權

實現(xiàn)邏輯

解析token，獲取token對應的授權類型，用戶信息，客戶端信息
根據(jù)權限規(guī)則判斷客戶端，用戶是否有對應接口的權限
有權限就放行，沒權限就返回403
<a name="Lndcz"></a>

spring cloud gateway api網(wǎng)關簡單實現(xiàn)

基于spring-security-oauth2實現(xiàn)，（未實現(xiàn)鑒權策略）

定制認證管理器

@Component public class OAuth2AuthenticationManager implements ReactiveAuthenticationManager { @Autowired private ResourceServerTokenServices tokenServices; @Autowired(required = false) private ClientDetailsService clientDetailsService; private String resourceId; @Override public Mono<Authentication> authenticate(Authentication authentication) { return Mono.defer(()->{ //獲取token String token = (String) authentication.getPrincipal(); //從tokenservice中加載用戶憑證 OAuth2Authentication auth = tokenServices.loadAuthentication(token); if (auth == null) { throw new InvalidTokenException("Invalid token: " + token); } Collection<String> resourceIds = auth.getOAuth2Request().getResourceIds(); if (resourceId != null && resourceIds != null && !resourceIds.isEmpty() && !resourceIds.contains(resourceId)) { throw new OAuth2AccessDeniedException("Invalid token does not contain resource id (" + resourceId + ")"); } //檢查客戶端詳情 checkClientDetails(auth); if (authentication.getDetails() instanceof OAuth2AuthenticationDetails) { OAuth2AuthenticationDetails details = (OAuth2AuthenticationDetails) authentication.getDetails(); // Guard against a cached copy of the same details if (!details.equals(auth.getDetails())) { // Preserve the authentication details from the one loaded by token services details.setDecodedDetails(auth.getDetails()); } } auth.setDetails(authentication.getDetails()); auth.setAuthenticated(true); return Mono.just(auth); }); } /** * 校驗第三方客戶端 * * @param auth */ private void checkClientDetails(OAuth2Authentication auth) { if (clientDetailsService != null) { ClientDetails client; try { client = clientDetailsService.loadClientByClientId(auth.getOAuth2Request().getClientId()); } catch (ClientRegistrationException e) { throw new OAuth2AccessDeniedException("Invalid token contains invalid client id"); } Set<String> allowed = client.getScope(); for (String scope : auth.getOAuth2Request().getScope()) { if (!allowed.contains(scope)) { throw new OAuth2AccessDeniedException( "Invalid token contains disallowed scope (" + scope + ") for this client"); } } } } }
<a name="URahL"></a>

定制權限管理器

public class OAuth2ReactiveAuthorizationManager<T> implements ReactiveAuthorizationManager<T> { private static final SecurityExpressionHandler EXPRESSION_HANDLER = new OAuth2WebSecurityExpressionHandler(); private static final AuthorizationDecision ACCESS_DENIED = new AuthorizationDecision(false); private static final AuthorizationDecision ACCESS_GRANTED = new AuthorizationDecision(true); private Expression express; public OAuth2ReactiveAuthorizationManager(Expression express) { this.express = express; } @Override public Mono<AuthorizationDecision> check(Mono<Authentication> authentication, T object) { return authentication .defaultIfEmpty(createAnonymouseAuthentication()) .map(a->{ StandardEvaluationContext ctx = createEvaluationContext(a); return ExpressionUtils.evaluateAsBoolean(express, ctx) ? ACCESS_GRANTED : ACCESS_DENIED; }); } private Authentication createAnonymouseAuthentication(){ return new AnonymousAuthenticationToken("anonymouse","anonymouse",Lists.newArrayList(new SimpleGrantedAuthority("anonymouse"))); } //創(chuàng)建權限控制表達式上下文 private StandardEvaluationContext createEvaluationContext(Authentication authentication){ //創(chuàng)建root對象 SecurityExpressionRoot root = new WebFluxSecurityExpressRoot(authentication); root.setPermissionEvaluator(new DenyAllPermissionEvaluator()); root.setTrustResolver( new AuthenticationTrustResolverImpl()); root.setDefaultRolePrefix("ROLE_"); //構建上下文對象，支持oauth2的權限校驗方法如 .antMatchers("/userprofile").access("#oauth2.hasScope('user_info')") StandardEvaluationContext ctx = new StandardEvaluationContext(); ctx.setVariable("oauth2", new OAuth2SecurityExpressionMethods(authentication)); ctx.setRootObject(root); return ctx; } public static List<ServerWebExchangeMatcherEntry<ReactiveAuthorizationManager<AuthorizationContext>>> buildDelegatingReactiveAuthorizationManagers(List<ApiEntity> apis){ ExpressionParser expressionParser = EXPRESSION_HANDLER.getExpressionParser(); //TODO 獲取權限控制元信息目前匹配器只支持 PathPatternParserServerWebExchangeMatcher return apis.stream().map(api-> convertServerWebExchangeMatcherEntry(api,expressionParser)).collect(Collectors.toList()); } public static ServerWebExchangeMatcherEntry<ReactiveAuthorizationManager<AuthorizationContext>> convertServerWebExchangeMatcherEntry(ApiEntity api,ExpressionParser expressionParser){ @NotNull String antPath = api.getAntPath(); @NotNull String method = api.getMethod(); @NotNull String express = api.getExpress(); //解析表達式 Expression expression = expressionParser.parseExpression(express); //創(chuàng)建匹配器 ServerWebExchangeMatcher matcher = new PathPatternParserServerWebExchangeMatcher(antPath, method==null?null:HttpMethod.valueOf(method.toUpperCase())); return new ServerWebExchangeMatcherEntry<>(matcher,new OAuth2ReactiveAuthorizationManager<>(expression)); } }

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av