ToB企服应用市场:ToB评测及商务社交产业平台

标题: 微服务安全Spring Security Oauth2实战 [打印本页]
作者: 三尺非寒    时间: 2024-8-27 06:27
标题: 微服务安全Spring Security Oauth2实战
Spring Authorization Server 是什么

Spring Authorization Server 是一个框架，它提供了 OAuth 2.1 和 OpenID Connect 1.0
规范以及其他相关规范的实现。它创建在 Spring Security 之上，为构建 OpenID Connect 1.0 身份提供者和 OAuth2
授权服务器产品提供了一个安全、轻量级和可定制的底子。说白了，Spring Authorization Server 就是一个**认证（授权）**服务器。
   官方主页：https://spring.io/projects/spring-authorization-server
  为什么有 Spring Authorization Server

因为随着网络和设备的发展，原先的 OAuth 2.0 已经不能满足现今的需求了，OAuth 社区对 OAuth 2.0
中的几种授权模式进行了弃取和优化，并增加一些新的特性，于是推出了 OAuth 2.1，而原先的 Spring Security OAuth 2.0 使用的是
OAuth 2.0 协议，为满足新的变化，Spring Security 团队重新写了一套叫 Spring Authorization Server
的认证授权框架来替换原先的 Spring Security OAuth 2.0。从官网中可以看到，原先的 Spring Security OAuth 2.0
已从 Spring Security 目录下被移除，接着是多出 Spring Authorization Server 作为单独项目。
Springboot2.x Oauth2 实现：

Springboot3.x Oauth2 实现：

OAuth2.0 协议先容

OAuth 2.0（Open
Authorization）是一种开放标准的授权协议，答应用户授权第三方应用访问其在某个服务提供者上的受保护资源，而无需将着实际的凭证（如用户名和暗码）分享给第三方应用。这种方式可以增加安全性，同时答应用户更好地控制其数据的访问权限。
   OAuth2.0协议：https://datatracker.ietf.org/doc/html/rfc6749
  脚色


使用授权服务器作为认证渠道的平台，一般指的是第三方应用。比方，微信提供 OAuth 2.0 认证平台，我们的 APP 支持微信登录，那么我们的 APP
对于微佩服务来说就是客户端。又比方，我们是政府某一平台的服务，我们平台维护的数据代表着足够高的权威，那么其他政府部门或合作方，需要从我们的平台中查询数据，大概利用我们平台的认证进行登录，那么其他部门或合作方的应用就是客户端。

简朴的说，就是提供接口给客户端访问的服务器，访问资源服务器上受保护的接口，则需要带上令牌（token）。比方分布式微服务中的用户服务、订单服务等部署的服务器都属于资源服务器。

拥有该资源的主体对象，一般指用户。客户端向资源服务器请求获取用户数据时，资源全部者参与确认授权或拒绝利用。

对客户端和用户进行身份认证、授权的服务器，认证授权乐成，则颁发令牌（token）。
OAuth2.0 协议的运行流程

OAuth 2.0 的运行流程如下图，摘自 RFC 6749：
（A）用户打开客户端以后，客户端要求用户给予授权。
（B）用户同意给予客户端授权。
（C）客户端使用上一步获得的授权，向授权服务器申请令牌。
（D）授权服务器对客户端进行认证以后，确认无误，同意发放令牌。
（E）客户端使用令牌，向资源服务器申请获取资源。
（F）资源服务器确认令牌无误，同意向客户端开放资源。
令牌（token）与暗码（password）的作用是一样的，都可以进入系统，但是有三点差异：
（1）令牌是短期的，到期会自动失效，用户自己无法修改。暗码一般长期有用，用户不修改，就不会发生变化。
（2）令牌可以被数据全部者撤销，会立即失效。暗码一般不答应被他人撤销。
（3）令牌有权限范围（scope）。对于网络服务来说，只读令牌就比读写令牌更安全。暗码一般是完整权限。
上面这些计划，包管了令牌既可以让第三方应用获得权限，同时又随时可控，不会危及系统安全。这就是 OAuth 2.0 的优点。
应用场景

OAuth 2.0 在许多差异的应用场景中都能够发挥作用，尤其是那些涉及到第三方应用步伐访问用户数据或资源的环境。以下是一些常见的 OAuth 2.0
应用场景：

这些只是 OAuth 2.0 可能应用的一些例子。根本上，任何需要实现安全的第三方应用步伐访问用户数据或资源的环境下，OAuth 2.0
都可能是一个合适的解决方案。
授权模式详解

授权码模式：应用最广泛，得当web应用/app/前端；
资源全部者暗码模式：官方应用；
客户端凭证模式：得当无用户参与的应用；
刷新令牌模式：得当令牌访问过期后刷新令牌；
客户端模式

客户端模式（Client Credentials
Grant）指客户端以自己的名义，而不是以用户的名义，向“服务提供商”进行授权。客户端模式是安全级别最低而且要求授权服务器对客户高度信任的模式，因为客户端向授权服务器请求认证授权的过程中，至始至终都没有用户的参与，未经过用户答应，客户端凭提供自己在授权服务器注册的信息即可在授权服务器完成认证授权，而客户端获得认证授权以后，则拥有从资源服务器利用用户数据的权限，这种模式一般应用于公司内部系统大概有着高度保密责任的合作伙伴之间的对接。
步骤如下：
（A）客户端向授权服务器进行身份认证，并要求一个访问令牌。
（B）授权服务器确认无误后，向客户端提供访问令牌。
客户端模式流程如下：
1、客户端首先在认证服务器注册好客户端信息，比如 client_id、client_secret 等。
2、认证服务器存储维护客户端信息。
3、客户端带上 client_id、client_secret、grant_type（写死client_credentials）等参数向认证服务器发起获取
token 请求。
4、认证服务器校验客户端信息，校验通过，则发放令牌（access_token），校验失败，则返回异常信息。
5、客户端乐成获取到令牌（access_token）后，就可以带着令牌去访问资源服务器了。
实现：
A 应用在下令行向 B 发出请求。
  1. > https://oauth.b.com/token?
  2. >   grant_type=client_credentials&
  3. >   client_id=CLIENT_ID&
  4. >   client_secret=CLIENT_SECRET
复制代码
B 网站验证通过以后，直接返回令牌。
暗码模式

如果你高度信任某个应用，RFC 6749
也答应用户把用户名和暗码，直接告诉该应用。该应用就使用你的暗码，申请令牌，这种方式称为“暗码模式”（password）。
暗码模式是一种安全级别较低而且要求资源拥有者（用户）完全信任客户端的模式，该模式可以理解为在客户端模式的底子上增加了对用户的账号、暗码在认证服务器进行校验的利用，是客户端代理用户的利用。在
OAuth 2.1 中，暗码模式已经被废除，在第三方平台上，使用暗码模式，对于用户来说是一种非常不安全的行为，假设某平台客户端支持 QQ 登录，用户使用自己
QQ 的账号、暗码在该平台上输入进行登录，则该平台将拥有用户 QQ 的账号、暗码，对于用户来说，将自己 QQ
的账号、暗码提供给第三方平台，这种行为是非常不安全的。
暗码模式一般得当应用在自己公司内部使用的系统和自己公司的 app 产品，比方一些 ERP、CRM、WMS
系统，因为都是自己公司的产品，这种环境下就不存在用户提供账号、暗码给第三方客户端进行代理登录的环境了。
步骤如下：
（A）用户向客户端提供用户名和暗码。
（B）客户端将用户名和暗码发给授权服务器，向后者请求令牌。
（C）授权服务器确认无误后，向客户端提供访问令牌。
暗码模式流程如下：
1、客户端首先在认证服务器注册好客户端信息。
2、认证服务器存储维护客户端信息。
3、用户提供认证平台的账号、暗码给客户端（这里的客户端可以是浏览器、APP、第三方应用的服务器）。
4、客户端带上 client_id、client_secret、grant_type（写死password）、username、password
等参数向认证服务器发起获取 token 请求。
5、认证服务器校验客户端信息，校验失败，则返回异常信息，校验通过，则往下继续校验用户验账号、暗码。
6、认证服务器校验用户账号、暗码，校验通过，则发放令牌（access_token），校验失败，则返回异常信息。
7、客户端乐成获取到令牌（access_token）后，就可以带着令牌去访问资源服务器了。
实现：
A 网站要求用户提供 B 网站的用户名和暗码，拿到以后，A 就直接向 B 请求令牌。整个过程中，客户端不得保存用户的暗码。
  1. > https://oauth.b.com/token?
  2. >   grant_type=password& # 授权方式是"密码模式"
  3. >   username=USERNAME&
  4. >   password=PASSWORD&
  5. >   client_id=CLIENT_ID
  6. >   client_secret=client_secret
复制代码
B 网站验证身份通过后，直接给出令牌。注意，这时不需要跳转，而是把令牌放在 JSON 数据内里，作为 HTTP 回应，A 因此拿到令牌。
授权码模式

授权码（authorization code）方式，指的是第三方应用先申请一个授权码，然后再用该授权码获取令牌。
授权码模式是 OAuth 2.0
协议中安全级别最高的一种认证模式，他与暗码模式一样，都需要使用到用户的账号信息在认证平台的登录利用，但有所差异的是，暗码模式是要求用户直接将自己在认证平台的账号、暗码提供给第三方应用（客户端），由第三方平台进行代理用户在认证平台的登录利用；而授权码模式则是用户在认证平台提供的界面进行登录，然后通过用户确认授权后才将一次性授权码提供给第三方应用，第三方应用拿到一次性授权码以后才去认证平台获取
token。
适用场景：目前市面上主流的第三方验证都是采用这种模式。
步骤如下：
（A）用户访问客户端，后者将前者导向授权服务器。
（B）用户选择是否给予客户端授权。
（C）假设用户给予授权，授权服务器将用户导向客户端事先指定的“重定向URI”（redirection URI），同时附上一个授权码。
（D）客户端收到授权码，附上早先的“重定向URI”，向授权服务器申请令牌。这一步是在客户端的背景的服务器上完成的，对用户不可见。
（E）授权服务器查对了授权码和重定向 URI，确认无误后，向客户端发送访问令牌（access token）和更新令牌（refresh token）。
授权码模式的时序图如下：
1、客户端首先在认证服务器注册好客户端信息。
2、认证服务器存储维护客户端信息。
3、用户在客户端上发起登录。
4、向认证服务器发起认证授权请求，比方[http://localhost:9000/auth/oauth/authorize?client_id=xxx&response_type=code&scope=message.read&redirect_uri=http://www.baidu.com](http://localhost:9000/auth/oauth/authorize?client_id=xxx&response_type=code&scope=message.read&redirect_uri=http://www.baidu.com)，注意，此时参数不需要client_secret。
5、认证服务器带上客户端参数，将利用引导至用户授权确认页面，用户在该页面进行授权确认利用。
6、用户在授权页面选择授权范围，点击确认提交，则带上客户端参数和用户授权范围向认证服务器获取授权码。注意，此处利用已经脱离了客户端。
7、认证服务器校验客户端信息和授权范围（因为客户端在认证平台注册的时候，注册信息包罗授权范围，如果用户选择的授权范围不在注册信息包罗的范围内，则将因权限不敷返回失败）。
8、校验通过，将授权码拼接到客户端注册的回调地址返回给客户端。
9、客户端拿到认证服务器返回的授权码后，带上客户端信息和授权码向认证服务器换取令牌（access_token）。
10、认证服务器校验授权码是否有用，如果有用，则返回令牌（access_token）；如果无效，则返回异常信息。
11、客户端乐成获取到令牌（access_token）后，就可以带着令牌去访问资源服务器了。
实现：
A 网站提供一个链接，用户点击后就会跳转到 B 网站，授权用户数据给 A 网站使用。下面就是 A 网站跳转 B 网站的一个示意链接。
  1. > https://b.com/oauth/authorize?
  2. >   response_type=code&            # 要求返回授权码（code）
  3. >   client_id=CLIENT_ID&           # 让 B 知道是谁在请求   
  4. >   redirect_uri=CALLBACK_URL&     # B 接受或拒绝请求后的跳转网址
  5. >   scope=read                     # 要求的授权范围（这里是只读）        
  6. >
复制代码
客户端申请授权的 URI，包罗以下参数：
   response_type：表现授权类型，必选项，此处的值固定为“code”
client_id：表现客户端的 ID，必选项
redirect_uri：表现重定向 URI，可选项
scope：表现申请的权限范围，可选项
state：表现客户端的当前状态，可以指定任意值，授权服务器会原封不动地返回这个值
  用户跳转后，B 网站会要求用户登录，然后询问是否同意给予 A 网站授权。用户表现同意，这时 B 网站就会跳回 redirect_uri
参数指定的网址。跳转时，会传回一个授权码，就像下面这样。
  1. > https://a.com/callback?code=AUTHORIZATION_CODE # code参数就是授权码
  2. >
复制代码
A 网站拿到授权码以后，就可以在后端，向 B 网站请求令牌。 用户不可见，服务端行为。
  1. > https://b.com/oauth/token?
  2. >  client_id=CLIENT_ID&
  3. >  client_secret=CLIENT_SECRET& # client_id和client_secret用来让 B 确认 A 的身份，client_secret参数是保密的，因此只能在后端发请求
  4. >  grant_type=authorization_code&   # 采用的授权方式是授权码
  5. >  code=AUTHORIZATION_CODE&          # 上一步拿到的授权码
  6. >  redirect_uri=CALLBACK_URL        # 令牌颁发后的回调网址   
  7. >
复制代码
B 网站收到请求以后，就会颁发令牌。详细做法是向 redirect_uri 指定的网址，发送一段 JSON 数据。
  1. {   
  2.    "access_token":"ACCESS_TOKEN",     # 令牌
  3.    "token_type":"bearer",
  4.    "expires_in":2592000,
  5.    "refresh_token":"REFRESH_TOKEN",
  6.    "scope":"read",
  7.    "uid":100101,
  8.    "info":{...}
  9. }
复制代码
简化模式

简化模式（也叫隐式模式）是相对于授权码模式而言的，对授权码模式的交互做了一下简化，省去了客户端使用授权码去认证服务器换取令牌（access_token）的利用，即用户在代理页面选择授权范围提交授权确认后，认证服务器通过客户端注册的回调地址直接就给客户端返回令牌（access_token）了。
这种方式把令牌直接传给前端，是很不安全的。因此，只能用于一些安全要求不高的场景，而且令牌的有用期必须非常短，通常就是会话期间（session）有用，浏览器关掉，令牌就失效了。
步骤如下：
（A）客户端将用户导向授权服务器。
（B）用户决定是否给于客户端授权。
（C）假设用户给予授权，授权服务器将用户导向客户端指定的“重定向URI”，并在 URI 的 Hash 部分包罗了访问令牌。
（D）浏览器向资源服务器发出请求，此中不包罗上一步收到的 Hash 值。
（E）资源服务器返回一个网页，此中包罗的代码可以获取 Hash 值中的令牌。
（F）浏览器实验上一步获得的脚本，提取出令牌。
（G）浏览器将令牌发给客户端。
简化模式时序图如下：
1、客户端首先在认证服务器注册好客户端信息。
2、认证服务器存储维护客户端信息。
3、用户在客户端上发起登录。
4、向认证服务器发起认证授权请求，比方[http://localhost:9000/auth/oauth/authorize?client_id=xxx&response_type=token&scope=message.read&redirect_uri=http://www.baidu.com](http://localhost:9000/auth/oauth/authorize?client_id=xxx&response_type=token&scope=message.read&redirect_uri=http://www.baidu.com)，注意，此时参数不需要
client_secret。
5、认证服务器带上客户端参数，将利用引导至用户授权确认页面，用户在该页面进行授权确认利用。
6、用户在授权页面选择授权范围，点击确认提交，则带上客户端参数和用户授权范围向认证服务器获取令牌（access_token）。注意，此处利用已经脱离了客户端。
7、认证服务器校验代理页面提交的参数信息，校验通过，则将令牌（access_token）拼接到客户端注册的回调地址返回给客户端；校验失败，则返回异常信息。
8、客户端乐成获取到令牌（access_token）后，就可以带着令牌去访问资源服务器了。
实现：
A 网站提供一个链接，要求用户跳转到 B 网站，授权用户数据给 A 网站使用。
  1. > https://b.com/oauth/authorize?
  2. >   response_type=token&          # response_type参数为token，表示要求直接返回令牌
  3. >   client_id=CLIENT_ID&
  4. >   redirect_uri=CALLBACK_URL&
  5. >   scope=read
  6. >
复制代码
用户跳转到 B 网站，登录后同意给予 A 网站授权。这时，B 网站就会跳回 redirect_uri 参数指定的跳转网址，而且把令牌作为 URL 参数，传给
A 网站。
  1. > https://a.com/callback#token=ACCESS_TOKEN # token参数就是令牌，A 网站直接在前端拿到令牌。
  2. >
复制代码
token刷新模式

令牌的有用期到了，如果让用户重新走一遍上面的流程，再申请一个新的令牌，很可能体验欠好，而且也没有必要。OAuth 2.0 答应用户自动更新令牌。token
刷新模式是对 access_token 过期的一种补办利用，这种补办利用，淘汰了用户重新利用登录的流程。OAuth 2.0 在给客户端颁发
access_token 的时候，同时也给客户端发放了 refresh_token，而 refresh_token 的有用期要远大于
access_token 的有用期。当客户端带着已过期的 access_token 去访问资源服务器中受保护的资源时，将会访问失败，此时就需要客户端使用
refresh_token 去获取新的 access_token。客户端端获取到新的 access_token
后，就可以带上他去访问资源服务器中受保护的资源了。
token 刷新模式时序图如下：
1、客户端向认证服务器请求认证授权。
2、认证服务器存返回 access_token、refresh_token、授权范围、过期时间。
3、access_token 过期后，客户端仍旧带着过期的 access_token 去请求资源服务器中受保护的资源。
4、资源服务器提示客户端，这是非法的 access_token。
5、客户端使用 refresh_token 向认证服务器获取新的 access_token。
6、认证服务器校验 refresh_token 的有用性，校验通过，则给客户端颁发新的 access_token；校验失败，则返回异常信息。
7、客户端乐成获取到新的 access_token 后，就可以带着新的 access_token 去访问资源服务器了。
详细方法是，B 网站颁发令牌的时候，一次性颁发两个令牌，一个用于获取数据，另一个用于获取新的令牌（refresh token 字段）。令牌到期前，用户使用
refresh token 发一个请求，去更新令牌。
  1. > https://b.com/oauth/token?
  2. >   grant_type=refresh_token&    # grant_type参数为refresh_token表示要求更新令牌
  3. >   client_id=CLIENT_ID&
  4. >   client_secret=CLIENT_SECRET&
  5. >   refresh_token=REFRESH_TOKEN    # 用于更新令牌的令牌
  6. >
复制代码
OAuth 2.1 协议先容

OAuth 2.1 去掉了 OAuth 2.0 中的暗码模式、简化模式，增加了设备授权码模式，同时也对授权码模式增加了 PKCE 扩展。
   OAuth 2.1 协议：<https://datatracker.ietf.org/doc/html/draft-ietf-
oauth-v2-1-07>
OAuth 2.1 的变化： https://note.youdao.com/s/DRnLx34U
  授权码模式+PKCE扩展

授权码模式交互过程，见之前 OAuth2.0 授权码模式的讲解。这里要说的是授权码模式如何拓展 PKCE（ Proof Key for Code
Exchange 代码互换验证密钥）。
在授权码模式的交互工程中，有一个环节比较薄弱，这个环节就是用户在代理页面确认授权的时候，容易受到恶意步伐的攻击，从而导致授权码被恶意步伐窃取，进而通过授权码窃取令牌，固然这个前提也需要恶意步伐已经植入到你的
PC 或手机当中。首先，来看一下官网中形貌的恶意步伐拦截攻击授权码的交互图：
（1）客户端向认证服务器发起获取授权码请求时，跳转至授权确认页面，用户通过用浏览器在授权页面进行授权确认。
（2）授权页面向认证服务器提交客户端参数和授权范围。
（3）认证服务器将授权码拼接在客户端注册的回调地址中返回给客户端。
（4）在步骤 3 认证服务器返回授权码的过程中，如果恶意步伐截取到授权码，那么他接下来就可以继续利用步骤 5 和步骤 6 了。
为了减轻这种攻击，官方增加 PKCE 扩展，先来看一下官方的交互图：
（A）客户端通过“/oauth2/authorize”地址向认证服务器发起获取授权码请求的时候增加两个参数，即 code_challenge 和
code_challenge_method，此中，code_challenge_method 是加密方法（比方：S256 或
plain），code_challenge 是使用 code_challenge_method 加密方法加密后的值。
（B）认证服务器给客户端返回授权码，同时记载下 code_challenge、code_challenge_method 的值。
（C）客户端使用 code 向认证服务器获取 Access Token 的时候，带上 code_verifier 参数，其值为步骤 A 加密前的初始值。
（D）认证服务器收到步骤 C 的请求时，将 code_verifier 的值使用 code_challenge_method
的方法进行加密，然后将加密后的值与步骤 A 中的 code_challenge 进行比较，看看是否划一。
上面交互过程中，恶意步伐如果在 B 处截获授权码后，使用授权码向认证服务器换取 Access Token，但由于恶意步伐没有 code_verifier
的值，因此在认证服务器无法校验通过，从而获取 Access Token 失败。
对于如何创建 code_challenge 的值，官网给出了下面两种对应的方法。

设备授权码模式

设备授权码模式，是一种为解决不便在当前设备上进行文本输入而提供的一种认证授权模式，比方：智能电视、媒体控制台、数字相框、打印机等。大家也可以脑补一下一些扫码登录的环境。使用设备授权码模式，有以下要求。
(1) 该设备已毗连到互联网。
(2) 设备能够支持发出 HTTPS 请求。
(3) 设备能够显示或以其他通信方式将 URI 和 Code 发给用户。
(4) 用户有辅助设备（如个人电脑或智能手机），他们可以从中处置处罚请求。
设备授权码登录官网交互图如下：
(A) 客户端带上包罗客户端信息的参数向认证服务器（地址：/oauth2/device_authorization）发起授权访问。
(B) 认证服务器给客户端返回设备码、用户码及需要用户验证用户码的 URI。
© 客户端指示用户需要在另一设备进行访问授权的 URI 和用户码。
(D) 用户根据 URI 打开页面，输入用户码和确认授权，向认证服务器发起认证请求。
(E) 客户端在完成步骤（C）之后就开始带上客户端信息和设备码向认证服务器轮询获取令牌信息。
(F) 认证服务器收到客户端使用设备码获取令牌信息的请求后，检查用户是否已提交授权确认，如果用户已提交授权确认，则返回令牌信息。
时序图如下：
拓展授权模式

OAuth2.1 也提供拓展授权模式的利用实现。固然 OAuth2.1
移除了暗码模式（password），但是通过拓展授权模式可以实现暗码模式。在实际应用中，客户端、授权服务器、资源服务器往往都是同一家公司的产品，那么这个时候，使用账号、暗码进行登录的环境也比较常见，此时就需要通过拓展授权模式来实现账号、暗码登录了。
   官网文档： <https://docs.spring.io/spring-authorization-
server/docs/current/reference/html/guides/how-to-ext-grant-type.html>
  OpenID Connect 1.0 协议

   OpenID Connect 1.0：https://openid.net/specs/openid-connect-core-1_0.html
  OpenID Connect 1.0 是 OAuth 2.0 协议之上的一个简朴的身份层。着实就是客户端向认证服务器请求认证授权的时候，多返回一个
id_token，该 id_token 是一串使用 jwt 加密过的字符串，如下如所示：
OpenID Connect 协议在抽象上遵循以下步骤。
Spring Authorization Server 实战

版本要求：
   Spring Authorization Server 版本：1.1.2
JDK 版本：17
Spring Boot 版本：3.1.4
  认证（授权）服务器搭建

Spring Authorization Server 重要组件：

Spring Security 的过滤器链，用于协议端点的。

Spring Security 的过滤器链，用于 Spring Security 的身份认证。

重要进行用户身份验证。

重要用于管理客户端。

用于署名访问令牌。

启动时生成的带有密钥的 KeyPair 实例，用于创建上面的 JWKSource。

JwtDecoder 的一个实例，用于解码已署名的访问令牌。

用于设置 Spring Authorization Server 的 AuthorizationServerSettings 实例。
1）引入依靠
  1. <!--Spring Authorization Server-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-oauth2-authorization-server</artifactId>
  5. </dependency>
复制代码
2）设置授权服务器
直接从官网[https://docs.spring.io/spring-authorization- server/docs/current/reference/html/getting- started.html](https://docs.spring.io/spring-authorization- server/docs/current/reference/html/getting-started.html)将 SecurityConfig 拷贝放到
config 下
  1. import com.nimbusds.jose.jwk.JWKSet;
  2. import com.nimbusds.jose.jwk.RSAKey;
  3. import com.nimbusds.jose.jwk.source.ImmutableJWKSet;
  4. import com.nimbusds.jose.jwk.source.JWKSource;
  5. import com.nimbusds.jose.proc.SecurityContext;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.core.annotation.Order;
  9. import org.springframework.http.MediaType;
  10. import org.springframework.security.config.Customizer;
  11. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  12. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  13. import org.springframework.security.core.userdetails.User;
  14. import org.springframework.security.core.userdetails.UserDetails;
  15. import org.springframework.security.core.userdetails.UserDetailsService;
  16. import org.springframework.security.oauth2.core.AuthorizationGrantType;
  17. import org.springframework.security.oauth2.core.ClientAuthenticationMethod;
  18. import org.springframework.security.oauth2.core.oidc.OidcScopes;
  19. import org.springframework.security.oauth2.jwt.JwtDecoder;
  20. import org.springframework.security.oauth2.server.authorization.client.InMemoryRegisteredClientRepository;
  21. import org.springframework.security.oauth2.server.authorization.client.RegisteredClient;
  22. import org.springframework.security.oauth2.server.authorization.client.RegisteredClientRepository;
  23. import org.springframework.security.oauth2.server.authorization.config.annotation.web.configuration.OAuth2AuthorizationServerConfiguration;
  24. import org.springframework.security.oauth2.server.authorization.config.annotation.web.configurers.OAuth2AuthorizationServerConfigurer;
  25. import org.springframework.security.oauth2.server.authorization.settings.AuthorizationServerSettings;
  26. import org.springframework.security.oauth2.server.authorization.settings.ClientSettings;
  27. import org.springframework.security.provisioning.InMemoryUserDetailsManager;
  28. import org.springframework.security.web.SecurityFilterChain;
  29. import org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint;
  30. import org.springframework.security.web.util.matcher.MediaTypeRequestMatcher;
  32. import java.security.KeyPair;
  33. import java.security.KeyPairGenerator;
  34. import java.security.interfaces.RSAPrivateKey;
  35. import java.security.interfaces.RSAPublicKey;
  36. import java.util.UUID;
  39. /**
  40. * https://docs.spring.io/spring-authorization-server/docs/current/reference/html/getting-started.html
  41. */
  42. @Configuration
  43. @EnableWebSecurity
  44. public class SecurityConfig {
  46.     /**
  47.     *  Spring Authorization Server 相关配置
  48.     *  主要配置OAuth 2.1和OpenID Connect 1.0
  49.     * @param http
  50.     * @return
  51.     * @throws Exception
  52.     */
  53.     @Bean
  54.     @Order(1)
  55.     public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http)
  56.     throws Exception {
  57.         OAuth2AuthorizationServerConfiguration.applyDefaultSecurity(http);
  58.         http.getConfigurer(OAuth2AuthorizationServerConfigurer.class)
  59.         //开启OpenID Connect 1.0（其中oidc为OpenID Connect的缩写）
  60.          .oidc(Customizer.withDefaults());  // Enable OpenID Connect 1.0
  61.       http
  62.          // Redirect to the login page when not authenticated from the
  63.          // authorization endpoint
  64.          //将需要认证的请求，重定向到login进行登录认证。
  65.          .exceptionHandling((exceptions) -> exceptions
  66.             .defaultAuthenticationEntryPointFor(
  67.                new LoginUrlAuthenticationEntryPoint("/login"),
  68.                new MediaTypeRequestMatcher(MediaType.TEXT_HTML)
  69.             )
  70.          )
  71.          // Accept access tokens for User Info and/or Client Registration
  72.          // 使用jwt处理接收到的access token
  73.          .oauth2ResourceServer((resourceServer) -> resourceServer
  74.             .jwt(Customizer.withDefaults()));
  76.       return http.build();
  77.    }
  79.    /**
  80.     *  Spring Security 过滤链配置（此处是纯Spring Security相关配置）
  81.     */
  82.    @Bean
  83.    @Order(2)
  84.    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http)
  85.          throws Exception {
  86.       http
  87.          .authorizeHttpRequests((authorize) -> authorize
  88.             .anyRequest().authenticated()
  89.          )
  90.          // Form login handles the redirect to the login page from the
  91.          // authorization server filter chain
  92.          .formLogin(Customizer.withDefaults());
  94.       return http.build();
  95.    }
  97.    /**
  98.     * 设置用户信息，校验用户名、密码
  99.     * @return
  100.     */
  101.    @Bean
  102.    public UserDetailsService userDetailsService() {
  103.       UserDetails userDetails = User.withDefaultPasswordEncoder()
  104.             .username("jay")
  105.             .password("123456")
  106.             .roles("USER")
  107.             .build();
  108.       //基于内存的用户数据校验
  109.       return new InMemoryUserDetailsManager(userDetails);
  110.    }
  112.    /**
  113.     * 注册客户端信息
  114.     *
  115.     * 查询认证服务器信息
  116.     * http://127.0.0.1:9000/.well-known/openid-configuration
  117.     *
  118.     * 获取授权码
  119.     * http://localhost:9000/oauth2/authorize?response_type=code&client_id=oidc-client&scope=profile&redirect_uri=http://www.baidu.com
  120.     *
  121.     */
  122.    @Bean
  123.    public RegisteredClientRepository registeredClientRepository() {
  124.       RegisteredClient oidcClient = RegisteredClient.withId(UUID.randomUUID().toString())
  125.             .clientId("oidc-client")
  126.             //{noop}开头，表示“secret”以明文存储
  127.             .clientSecret("{noop}secret")
  128.             .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
  129.             .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
  130.             .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
  131.             .authorizationGrantType(AuthorizationGrantType.CLIENT_CREDENTIALS)
  132.             //.redirectUri("http://spring-oauth-client:9001/login/oauth2/code/messaging-client-oidc")
  133.             //我们暂时还没有客户端服务，以免重定向跳转错误导致接收不到授权码
  134.             .redirectUri("http://www.baidu.com")
  135.             .postLogoutRedirectUri("http://127.0.0.1:8080/")
  136.             .scope(OidcScopes.OPENID)
  137.             .scope(OidcScopes.PROFILE)
  138.             .clientSettings(ClientSettings.builder().requireAuthorizationConsent(true).build())
  139.             .build();
  141.       //配置基于内存的客户端信息
  142.       return new InMemoryRegisteredClientRepository(oidcClient);
  143.    }
  145.    /**
  146.     * 配置 JWK，为JWT(id_token)提供加密密钥，用于加密/解密或签名/验签
  147.     * JWK详细见：https://datatracker.ietf.org/doc/html/draft-ietf-jose-json-web-key-41
  148.     */
  149.    @Bean
  150.    public JWKSource<SecurityContext> jwkSource() {
  151.       KeyPair keyPair = generateRsaKey();
  152.       RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
  153.       RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
  154.       RSAKey rsaKey = new RSAKey.Builder(publicKey)
  155.             .privateKey(privateKey)
  156.             .keyID(UUID.randomUUID().toString())
  157.             .build();
  158.       JWKSet jwkSet = new JWKSet(rsaKey);
  159.       return new ImmutableJWKSet<>(jwkSet);
  160.    }
  162.    /**
  163.     *  生成RSA密钥对，给上面jwkSource() 方法的提供密钥对
  164.     */
  165.    private static KeyPair generateRsaKey() {
  166.       KeyPair keyPair;
  167.       try {
  168.          KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
  169.          keyPairGenerator.initialize(2048);
  170.          keyPair = keyPairGenerator.generateKeyPair();
  171.       }
  172.       catch (Exception ex) {
  173.          throw new IllegalStateException(ex);
  174.       }
  175.       return keyPair;
  176.    }
  178.    /**
  179.     * 配置jwt解析器
  180.     */
  181.    @Bean
  182.    public JwtDecoder jwtDecoder(JWKSource<SecurityContext> jwkSource) {
  183.       return OAuth2AuthorizationServerConfiguration.jwtDecoder(jwkSource);
  184.    }
  186.    /**
  187.     * 配置认证服务器请求地址
  188.     */
  189.    @Bean
  190.    public AuthorizationServerSettings authorizationServerSettings() {
  191.       //什么都不配置，则使用默认地址
  192.       return AuthorizationServerSettings.builder().build();
  193.    }
  194. }
复制代码
在上面 SecurityConfig 代码中，我们已经开启了 OpenID Connect 1.0，于是我们就可以使用
[http://127.0.0.1:9000/.well-known/openid- configuration](http://127.0.0.1:9000/.well-known/openid-configuration)
地址请求查看授权服务器信息了。
可以参考源码：OidcProviderConfigurationEndpointFilter，该类是 Spring Security
过滤链中的一个过滤器，当发起“/.well-known/openid-configuration”请求时，会被
OidcProviderConfigurationEndpointFilter 拦截。
上面的设置信息中，此中 authorization_endpoint 为授权码的授权地址，device_authorization_endpoint
为设备授权码的授权地址，token_endpoint 为获取 token 的地址。
授权码模式测试

使用 [http://localhost:9000/oauth2/authorize?response_type=code&client_id=oidc- client&scope=profile](http://localhost:9000/oauth2/authorize?response_type=code&client_id=oidc- client&scope=profile) openid&redirect_uri=[http://www.baidu.com](http://www.baidu.com)
请求获取授权码，则跳转至下面登录页面。
输入用户名：jay，暗码：123456，则跳转至授权页面：
勾选授权信息 profile，点击提交按钮，则返回如下结果：
从浏览器地址栏中，我们看到授权服务器已经返回了授权码 code，接下来，我们使用授权 code
向[http://localhost:9000/oauth2/token](http://localhost:9000/oauth2/token)地址请求获取令牌。
postman 测试：
需要带上 client_id 和 client_secret
结果如下：
到此，授权码模式的流程就完成了。
刷新令牌测试

测试[http://localhost:9000/oauth2/token](http://localhost:9000/oauth2/token)
地址，参数授权类型 grant_type 的值改为 refresh_token，传入授权码模式返回的 refresh_token
客户端模式测试

带上 client_id、client_secret，指定客户端模式 grant_type 为
client_credentials，访问[http://localhost:9000/oauth2/token](http://localhost:9000/oauth2/token)
客户端搭建

客户端的重要职责是辨认用户利用是否有身份认证，已认证则放行，未认证则拒绝或引导到认证服务器进行认证。
前面我们先容了授权服务器的搭建，由于我们没有自己的客户端回调地址，在测试过程中，我们是使用[http://www.baidu.com](http://www.baidu.com)作为回调地址，获取到授权码
code 后，再使用 postman 去获取令牌信息的。接下来，我们将搭建自己的客户端，实现连贯的令牌获取利用， 利用流程如下：
业务场景

假设我们公司的 web 平台产品支持微信登录，那么对于微信平台来说，我们的 web
平台就是客户端（第三方），那么，首先我们就得需要在微信开发者平台中注册客户端信息，比方：申请客户端id（client_id，微信平台叫
appId）、密钥（secret）、设置授权码回调地址等。前面我们搭建的授权服务器就类似微信平台的授权服务器，接下来要搭建的客户端 auth-client
就类似公司的 web 平台。
客户端接入 oauth2-client

Spring Security OAuth2 Client 组件先容：

  1. <!--spring-boot-starter-oauth2-client-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-oauth2-client</artifactId>
  5. </dependency>
  6. <!--spring-boot-starter-web-->
  7. <dependency>
  8.     <groupId>org.springframework.boot</groupId>
  9.     <artifactId>spring-boot-starter-web</artifactId>
  10. </dependency>
复制代码
2）设置 application.yml
  1. server:
  2.   port: 9001
  4. logging:
  5.   level:
  6.     org.springframework.security: trace
  8. spring:
  9.   application:
  10.     name: spring-oauth-client
  11.   security:
  12.     oauth2:
  13.       client:
  14.         provider:
  15.           #认证服务器信息
  16.           oauth-server:
  17.             #授权地址
  18.             issuer-uri: http://spring-oauth-server:9000
  19.             authorizationUri: ${spring.security.oauth2.client.provider.oauth-server.issuer-uri}/oauth2/authorize
  20.             #令牌获取地址
  21.             tokenUri: ${spring.security.oauth2.client.provider.oauth-server.issuer-uri}/oauth2/token
  22.         registration:
  23.           messaging-client-oidc:
  24.             #认证提供者，标识由哪个认证服务器进行认证，和上面的oauth-server进行关联
  25.             provider: oauth-server
  26.             #客户端名称
  27.             client-name: web平台
  28.             #客户端id，从认证平台申请的客户端id
  29.             client-id: web-client-id
  30.             #客户端秘钥
  31.             client-secret: secret
  32.             #客户端认证方式
  33.             client-authentication-method: client_secret_basic
  34.             #使用授权码模式获取令牌（token）
  35.             authorization-grant-type: authorization_code
  36.             #回调地址，接收认证服务器回传code的接口地址，之前我们是使用http://www.baidu.com代替
  37.             # 注意：和认证服务器配置的回调地址要一致
  38.             redirect-uri: http://spring-oauth-client:9001/login/oauth2/code/messaging-client-oidc
  39.             scope:
  40.               - profile
  41.               - openid
复制代码
注意：上面设置中出现两个域名，分别是 spring-oauth-client、spring-oauth-
server，因为我是在同一台机器上进行启动客户端和认证服务器的，ip 都是 127.0.0.1，在 ip 雷同的环境下，会出现 cookie
覆盖的环境，这会导致认证服务器重定向到客户端地址时会出现[authorization_request_not_found]异常，为解决这个问题，可以在系统的
hosts 文件添加了一行 IP 域名映射，即 127.0.0.1 spring-oauth-client spring-oauth-server。
3）新建测试类
  1. @RestController
  2. public class AuthenticationController {
  4.     @GetMapping("/token")
  5.     @ResponseBody
  6.     public OAuth2AuthorizedClient token(@RegisteredOAuth2AuthorizedClient OAuth2AuthorizedClient oAuth2AuthorizedClient) {
  7.         // 通过OAuth2AuthorizedClient对象获取到客户端和令牌相关的信息，然后直接返回给前端页面
  8.         return oAuth2AuthorizedClient;
  9.     }
  10. }
复制代码
客户端测试

启动认证服务器和客户端服务，浏览器输入[http://spring-oauth-client:9001/token](http://spring- oauth-client:9001/token)地址发起接口访问。此时我们会看到，浏览器地址被重定向到认证服务器[http://spring- oauth-server:9000/login](http://spring-oauth-server:9000/login)中被要求进行登录：
输入用户在认证服务器的用户名：jay，暗码：123456，则跳转到认证服务器授权页面：
勾选授权信息 profile，点击提交按钮，则返回如下结果：
此时我们看到了浏览器中的地址为[http://spring-oauth- client:9001/token?continue](http://spring-oauth- client:9001/token?continue)，且返回了客户端及token信息。也看到了认证服务器将授权码拼接到了回调地址[http://spring- oauth-client:9001/login/oauth2/code/messaging-client-oidc](http://spring- oauth-client:9001/login/oauth2/code/messaging-client-oidc)中传给客户端。
资源服务器搭建

资源服务器在分布式服务中就是指用户服务、商品服务、订单服务那些了，访问资源服务器中受保护的资源，都需要带上令牌（token）进行访问。
资源服务器往往和客户端一起共同使用，客户端侧重于身份认证，资源服务器侧重于权限校验，如果在 Spring Cloud（Alibaba）
微服务架构中，可以将客户端框架 spring-boot-starter-oauth2-client 集成到网关服务上，将资源服务器框架 spring-
boot-starter-oauth2-resource-server 集成到用户服务、商品服务、订单服务等微服务上。
下面我们开始来搭建资源服务器。客户端、资源服务器交互时序图如下：
资源服务器搭建

1）引入依靠
  1. <!--spring-boot-starter-oauth2-resource-server-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
  5. </dependency>
  6. <!--spring-boot-starter-web-->
  7. <dependency>
  8.     <groupId>org.springframework.boot</groupId>
  9.     <artifactId>spring-boot-starter-web</artifactId>
  10. </dependency>
复制代码
2）设置 application.yml
  1. server:
  2.   port: 9002
  4. logging:
  5.   level:
  6.     org.springframework.security: trace
  8. spring:
  9.   application:
  10.     name: spring-oauth-resource
  11.   security:
  12.     oauth2:
  13.       resource-server:
  14.         jwt:
  15.           issuer-uri: http://spring-oauth-server:9000
复制代码
3）设置 Spring Security
  1. @Configuration
  2. @EnableWebSecurity
  3. @EnableMethodSecurity(jsr250Enabled = true, securedEnabled = true)
  4. public class ResourceServerConfig {
  6.     @Bean
  7.     SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
  9.         http.authorizeHttpRequests((authorizeHttpRequests) -> authorizeHttpRequests
  10.                                    // 所有的访问都需要通过身份认证
  11.                                    .anyRequest().authenticated()
  12.                                   )
  13.         .oauth2ResourceServer((oauth2ResourceServer) -> oauth2ResourceServer
  14.                               .jwt(Customizer.withDefaults())
  16.                              );
  18.         return http.build();
  19.     }
  21. }
复制代码
资源服务器测试

1）添加测试接口类
  1. @RestController
  2. public class MessagesController {
  4.     @GetMapping("/messages1")
  5.     public String getMessages1() {
  6.         return " hello Message 1";
  7.     }
  9.     @GetMapping("/messages2")
  10.     @PreAuthorize("hasAuthority('SCOPE_profile')")
  11.     public String getMessages2() {
  12.         return " hello Message 2";
  13.     }
  15.     @GetMapping("/messages3")
  16.     @PreAuthorize("hasAuthority('SCOPE_Message')")
  17.     public String getMessages3() {
  18.         return " hello Message 3";
  19.     }
  21. }
复制代码
上面的 MessagesController 类中，有三个接口，分别是 messages1、messages2、messages3，由于接口资源地址没有在
Spring Security 设置中放开，因此三个接口访问都需要传入 accessToken。此中，messages1 接口的要求只需传入
accessToken，messages2 接口要求传入 accessToken 和拥有 profile 权限，messages3 接口要求传入
accessToken 和拥有 Message 权限。
2）测试
postman
直接访问[http://localhost:9002/messages1](http://localhost:9002/messages1)地址，不带
token，则返回如下 401 结果：
使用[http://spring-oauth-client:9001/token](http://spring-oauth- client:9001/token)地址，向客户端发起请求，获取token：
然后请求[http://localhost:9002/messages1](http://localhost:9002/messages1)地址，带上
accessToken，则返回如下乐成结果：
再请求[http://localhost:9002/messages2](http://localhost:9002/messages2)地址，带上
accessToken，同样返回乐成，结果如下：
再请求[http://localhost:9002/messages3](http://localhost:9002/messages3)地址，带上
accessToken，则返回 403 了，结果如下：
打开 Headers 信息，看到 WWW-Authenticate 返回错误信息了，意思是权限不敷，因为 messages3 接口需要有 Message
权限。
自定义异常处置处罚类

在 Spring Authorization Server 的过滤链中有一个叫 ExceptionTranslationFilter
的过滤器，在认证或授权过程中，如果出现 AuthenticationException（认证异常）和
AccessDeniedException（授权异常），都由 ExceptionTranslationFilter 过滤器捕捉进行处置处罚。
ExceptionTranslationFilter 会处置处罚捕捉到的 AuthenticationException 或
AccessDeniedException异常。
如果我们要自定义对 AuthenticationException、AccessDeniedException
异常的处置处罚，那么我们就需自定义AuthenticationEntryPoint、AccessDeniedException
的实现类，然后将自定义的异常实现类设置到设置中去。我们可以通过 accessDeniedHandler(AccessDeniedHandler
accessDeniedHandler)、authenticationEntryPoint(AuthenticationEntryPoint
authenticationEntryPoint) 方法，将自定义的异常设置到设置中去。
1）自定义 AuthenticationEntryPoint
  1. public class MyAuthenticationEntryPoint implements AuthenticationEntryPoint {
  3.     @Override
  4.     public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
  6.         if(authException instanceof InsufficientAuthenticationException){
  7.             String accept = request.getHeader("accept");
  8.             if(accept.contains(MediaType.TEXT_HTML_VALUE)){
  9.                 //如果是html请求类型，则返回登录页
  10.                 LoginUrlAuthenticationEntryPoint loginUrlAuthenticationEntryPoint = new LoginUrlAuthenticationEntryPoint("/login");
  11.                 loginUrlAuthenticationEntryPoint.commence(request,response,authException);
  12.             }else {
  13.                 //如果是api请求类型，则返回json
  14.                 ResponseResult.exceptionResponse(response,"需要带上令牌进行访问");
  15.             }
  16.         }else if(authException instanceof InvalidBearerTokenException){
  17.             ResponseResult.exceptionResponse(response,"令牌无效或已过期");
  18.         }else{
  19.             ResponseResult.exceptionResponse(response,authException);
  20.         }
  21.     }
  22. }
复制代码
2）自定义AccessDeniedHandler
  1. public class MyAccessDeniedHandler implements AccessDeniedHandler {
  2.     @Override
  3.     public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
  4.         if(request.getUserPrincipal() instanceof AbstractOAuth2TokenAuthenticationToken){
  5.             ResponseResult.exceptionResponse(response,"权限不足");
  6.         }else {
  7.             ResponseResult.exceptionResponse(response,accessDeniedException);
  8.         }
  9.     }
  10. }
复制代码
3）SecurityConfig 中设置异常
  1. http
  2. .oauth2ResourceServer((resourceServer) -> resourceServer
  3.     .jwt(Customizer.withDefaults())
  4.     .authenticationEntryPoint(new MyAuthenticationEntryPoint())
  5.     .accessDeniedHandler(new MyAccessDeniedHandler())
  6. );
复制代码
4）测试
令牌过期：
没有带上令牌：
权限不敷：
基于数据库存储改造授权服务器

客户端注册信息存储改造
1）引入依靠
  1. <!--Spring Authorization Server-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-oauth2-authorization-server</artifactId>
  5. </dependency>
  6. <!--lombok--><dependency>    <groupId>org.projectlombok</groupId>    <artifactId>lombok</artifactId></dependency><!--mysql--><dependency>    <groupId>com.mysql</groupId>    <artifactId>mysql-connector-j</artifactId></dependency><!-- mybatis-plus 3.5.3及以上版本 才支持 spring boot 3--><dependency>    <groupId>com.baomidou</groupId>    <artifactId>mybatis-plus-boot-starter</artifactId>    <version>3.5.3.1</version></dependency><!-- 添加spring security cas支持 --><dependency>    <groupId>org.springframework.security</groupId>    <artifactId>spring-security-cas</artifactId></dependency>
复制代码
注意：这里需添加 spring-security-cas 依靠，否则启动时报 java.lang.ClassNotFoundException: org.springframework.security.cas.jackson2.CasJackson2Module 错误。
2）准备 sql 脚本，创建 oauth-server 数据库
在上面的认证过程中，客户端信息是基于内存的，写死在代码中，现在我们将他改造从数据库中读取。
我们在 org.springframework.security.oauth2.server.authorization 包下，可以看到
oauth2-registered-client-schema.sql、oauth2-authorization-consent-
schema.sql、oauth2-authorization-schema.sql 三个 sql 文件。
上面三个 sql 文件整理如下：
  1. /**
  2. * 客户端信息表
  3. */
  4. CREATE TABLE oauth2_registered_client (
  5.   id varchar(100) NOT NULL,
  6.   client_id varchar(100) NOT NULL,
  7.   client_id_issued_at timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL,
  8.   client_secret varchar(200) DEFAULT NULL,
  9.   client_secret_expires_at timestamp DEFAULT NULL,
  10.   client_name varchar(200) NOT NULL,
  11.   client_authentication_methods varchar(1000) NOT NULL,
  12.   authorization_grant_types varchar(1000) NOT NULL,
  13.   redirect_uris varchar(1000) DEFAULT NULL,
  14.   post_logout_redirect_uris varchar(1000) DEFAULT NULL,
  15.   scopes varchar(1000) NOT NULL,
  16.   client_settings varchar(2000) NOT NULL,
  17.   token_settings varchar(2000) NOT NULL,
  18.   PRIMARY KEY (id)
  19. );
  22. /**
  23. * 授权确认表
  24. */
  25. CREATE TABLE oauth2_authorization_consent (
  26.   registered_client_id varchar(100) NOT NULL,
  27.   principal_name varchar(200) NOT NULL,
  28.   authorities varchar(1000) NOT NULL,
  29.   PRIMARY KEY (registered_client_id, principal_name)
  30. );
  33. /**
  34. * 授权信息表
  35. */
  36. CREATE TABLE oauth2_authorization (
  37.   id varchar(100) NOT NULL,
  38.   registered_client_id varchar(100) NOT NULL,
  39.   principal_name varchar(200) NOT NULL,
  40.   authorization_grant_type varchar(100) NOT NULL,
  41.   authorized_scopes varchar(1000) DEFAULT NULL,
  42.   attributes blob DEFAULT NULL,
  43.   state varchar(500) DEFAULT NULL,
  44.   authorization_code_value blob DEFAULT NULL,
  45.   authorization_code_issued_at timestamp DEFAULT NULL,
  46.   authorization_code_expires_at timestamp DEFAULT NULL,
  47.   authorization_code_metadata blob DEFAULT NULL,
  48.   access_token_value blob DEFAULT NULL,
  49.   access_token_issued_at timestamp DEFAULT NULL,
  50.   access_token_expires_at timestamp DEFAULT NULL,
  51.   access_token_metadata blob DEFAULT NULL,
  52.   access_token_type varchar(100) DEFAULT NULL,
  53.   access_token_scopes varchar(1000) DEFAULT NULL,
  54.   oidc_id_token_value blob DEFAULT NULL,
  55.   oidc_id_token_issued_at timestamp DEFAULT NULL,
  56.   oidc_id_token_expires_at timestamp DEFAULT NULL,
  57.   oidc_id_token_metadata blob DEFAULT NULL,
  58.   refresh_token_value blob DEFAULT NULL,
  59.   refresh_token_issued_at timestamp DEFAULT NULL,
  60.   refresh_token_expires_at timestamp DEFAULT NULL,
  61.   refresh_token_metadata blob DEFAULT NULL,
  62.   user_code_value blob DEFAULT NULL,
  63.   user_code_issued_at timestamp DEFAULT NULL,
  64.   user_code_expires_at timestamp DEFAULT NULL,
  65.   user_code_metadata blob DEFAULT NULL,
  66.   device_code_value blob DEFAULT NULL,
  67.   device_code_issued_at timestamp DEFAULT NULL,
  68.   device_code_expires_at timestamp DEFAULT NULL,
  69.   device_code_metadata blob DEFAULT NULL,
  70.   PRIMARY KEY (id)
  71. );
复制代码
新建 mysql 数据库 oauth-server，实验上面的 sql 语句。
3）注册客户端信息
将上面代码中注册的客户端信息整理成 sql 语句插入数据库表。
  1. INSERT INTO `oauth-server`.`oauth2_registered_client` (`id`, `client_id`, `client_id_issued_at`, `client_secret`, `client_secret_expires_at`, `client_name`, `client_authentication_methods`, `authorization_grant_types`, `redirect_uris`, `post_logout_redirect_uris`, `scopes`, `client_settings`, `token_settings`) VALUES ('3eacac0e-0de9-4727-9a64-6bdd4be2ee1f', 'oidc-client', '2023-07-12 07:33:42', '$2a$10$.J0Rfg7y2Mu8AN8Dk2vL.eBFa9NGbOYCPOAFEw.QhgGLVXjO7eFDC', NULL, '3eacac0e-0de9-4727-9a64-6bdd4be2ee1f', 'client_secret_basic', 'refresh_token,authorization_code', 'http://www.baidu.com', 'http://127.0.0.1:8080/', 'openid,profile', '{"@class":"java.util.Collections$UnmodifiableMap","settings.client.require-proof-key":false,"settings.client.require-authorization-consent":true}', '{"@class":"java.util.Collections$UnmodifiableMap","settings.token.reuse-refresh-tokens":true,"settings.token.id-token-signature-algorithm":["org.springframework.security.oauth2.jose.jws.SignatureAlgorithm","RS256"],"settings.token.access-token-time-to-live":["java.time.Duration",300.000000000],"settings.token.access-token-format":{"@class":"org.springframework.security.oauth2.server.authorization.settings.OAuth2TokenFormat","value":"self-contained"},"settings.token.refresh-token-time-to-live":["java.time.Duration",3600.000000000],"settings.token.authorization-code-time-to-live":["java.time.Duration",300.000000000],"settings.token.device-code-time-to-live":["java.time.Duration",300.000000000]}');
复制代码
注意：此时将客户端密钥 {noop}secret，改为密文存储。
4）添加数据库毗连，application.yml 设置如下
  1. spring:
  2.   application:
  3.     name: spring-oauth-server
  4.   datasource:
  5.     driver-class-name: com.mysql.cj.jdbc.Driver
  6.     url: jdbc:mysql://localhost:3306/oauth-server?serverTimezone=UTC&userUnicode=true&characterEncoding=utf-8
  7.     username: root
  8.     password: root
复制代码
5）在 SecurityConfig 中分别注入
RegisteredClientRepository、OAuth2AuthorizationService、OAuth2AuthorizationConsentService
。
  1. /**
  2. * 客户端信息
  3. * 对应表：oauth2_registered_client
  4. */
  5. @Bean
  6. public RegisteredClientRepository registeredClientRepository(JdbcTemplate jdbcTemplate) {
  7. return new JdbcRegisteredClientRepository(jdbcTemplate);
  8. }
  11. /**
  12. * 授权信息
  13. * 对应表：oauth2_authorization
  14. */
  15. @Bean
  16. public OAuth2AuthorizationService authorizationService(JdbcTemplate jdbcTemplate, RegisteredClientRepository registeredClientRepository) {
  17.     return new JdbcOAuth2AuthorizationService(jdbcTemplate, registeredClientRepository);
  18. }
  20. /**
  21. * 授权确认
  22. *对应表：oauth2_authorization_consent
  23. */
  24. @Bean
  25. public OAuth2AuthorizationConsentService authorizationConsentService(JdbcTemplate jdbcTemplate, RegisteredClientRepository registeredClientRepository) {
  26.     return new JdbcOAuth2AuthorizationConsentService(jdbcTemplate, registeredClientRepository);
  27. }
复制代码
用户信息存储改造

在 SecurityConfig 类中的 UserDetailsService 也是基于内存的，用户信息在代码中写死，我们也把他改成从数据库中读取，新建
sys_user 表如下。
  1. CREATE TABLE `sys_user` (
  2.   `id` bigint NOT NULL AUTO_INCREMENT COMMENT 'id',
  3.   `username` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT '' COMMENT '用户名',
  4.   `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT '' COMMENT '密码',
  5.   `name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '姓名',
  6.   `description` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '描述',
  7.   `status` tinyint DEFAULT NULL COMMENT '状态（1：正常 0：停用）',
  8.   PRIMARY KEY (`id`) USING BTREE,
  9.   UNIQUE KEY `idx_username` (`username`) USING BTREE
  10. ) ENGINE=InnoDB AUTO_INCREMENT=14 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci ROW_FORMAT=DYNAMIC COMMENT='用户表';
  12. INSERT INTO `oauth-server`.`sys_user` (`id`, `username`, `password`, `name`, `description`, `status`) VALUES (1, 'jay', '$2a$10$8fyY0WbNAr980e6nLcPL5ugmpkLLH3serye5SJ3UcDForTW5b0Sx.', '测试用户', 'Spring Security 测试用户', 1);
复制代码
给 sys_user
增加对应的对应的实体和功能实现类，SysUserEntity、SysUserMapper、SysUserService、SysUserServiceImpl
代码如下。
  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. @TableName("sys_user")
  5. public class SysUserEntity implements Serializable {
  7.     /**
  8.      * 主键
  9.      */
  10.     @TableId(type = IdType.AUTO)
  11.     private Integer id;
  13.     /**
  14.      * 用户名
  15.      */
  16.     private String username;
  18.     /**
  19.      * 密码
  20.      */
  21.     private String password;
  23.     /**
  24.      * 名字
  25.      */
  26.     private String name;
  28.     /**
  29.      * 描述
  30.      */
  31.     private String description;
  33.     /**
  34.      * 状态
  35.      */
  36.     private Integer status;
  38. }
  40. @Mapper
  41. public interface SysUserMapper extends BaseMapper<SysUserEntity> {
  43. }
  45. public interface SysUserService {
  47.     /**
  48.      *
  49.      * @param username
  50.      * @return
  51.      * @author  Rommel
  52.      * @date    2023/7/12-23:48
  53.      * @version 1.0
  54.      * @description  根据用户名查询用户信息
  55.      */
  56.     SysUserEntity selectByUsername(String username);
  57. }
  59. @Service
  60. public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUserEntity> implements SysUserService {
  61.     @Override
  62.     public SysUserEntity selectByUsername(String username) {
  63.         LambdaQueryWrapper<SysUserEntity> lambdaQueryWrapper = new LambdaQueryWrapper();
  64.         lambdaQueryWrapper.eq(SysUserEntity::getUsername,username);
  65.         return this.getOne(lambdaQueryWrapper);
  66.     }
  67. }
复制代码
SecurityConfig 类，将 UserDetailsService 基于内存实现的代码注释掉，增加 PasswordEncoder
设置，SecurityConfig 改造后代码如下。
  1. /**
  2.      *设置用户信息，校验用户名、密码
  3.      */
  4. //    @Bean
  5. //    public UserDetailsService userDetailsService() {
  6. //        UserDetails userDetails = User.withDefaultPasswordEncoder()
  7. //                .username("jay")
  8. //                .password("123456")
  9. //                .roles("USER")
  10. //                .build();
  11. //        //基于内存的用户数据校验
  12. //        return new InMemoryUserDetailsManager(userDetails);
  13. //    }
  15. @Bean
  16. public PasswordEncoder passwordEncoder() {
  17.     return new BCryptPasswordEncoder();
  18. }
复制代码
创建 UserDetailsServiceImpl 类继承 UserDetailsService 接口，添加 @Service 注解交给 Spring
容器管理，重写 loadUserByUsername(String username)
方法，实现用户信息从数据库查询，UserDetailsServiceImpl 代码如下。
  1. @Service
  2. public class UserDetailsServiceImpl implements UserDetailsService {
  4.     @Resource
  5.     private SysUserService sysUserService;
  7.     @Override
  8.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  10.         SysUserEntity sysUserEntity = sysUserService.selectByUsername(username);
  11.         List<SimpleGrantedAuthority> grantedAuthorityList = Arrays.asList("USER").stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
  13.         return new User(username,sysUserEntity.getPassword(),grantedAuthorityList);
  14.     }
  15. }
复制代码
测试

启动服务，再次访问
[http://localhost:9000/oauth2/authorize?response_type=code&client_id=oidc- client&scope=profile](http://localhost:9000/oauth2/authorize?response_type=code&client_id=oidc- client&scope=profile) openid&redirect_uri=[http://www.baidu.com](http://www.baidu.com) 地址，会跳转到登录界面
输入用户名：jay，暗码：123456，则跳转至授权页面
勾选授权信息 profile，点击提交按钮，则返回如下结果
SSO 单点登录实战

单点登录（Single Sign On），简称为
SSO，是比较盛行的企业业务整合的解决方案之一。它的用途在于，不管多么复杂的应用群，只要在用户权限范围内，那么就可以做到，用户只需要登录一次就可以访问权限范围内的全部应用子系统。
实现思路

单点登录涉及到多个客户端，客户端就以订单服务、商品服务为例。以下是单点登录中，订单服务、商品服务、认证服务器的交互时序图：
授权服务器搭建

参考前面的授权服务器搭建例子。
订单服务搭建

订单服务作为客户端，参考前面客户端的搭建。
application.yml 设置如下：
  1. server:
  2.   ip: spring-oauth-client-order
  3.   port: 9003
  5. logging:
  6.   level:
  7.     org.springframework.security: trace
  9. spring:
  10.   application:
  11.     name: spring-oauth-client-order
  12.   security:
  13.     oauth2:
  14.       client:
  15.         provider:
  16.           #认证服务器信息
  17.           oauth-server:
  18.             #授权地址
  19.             issuer-uri: http://spring-oauth-server:9000
  20.             authorizationUri: ${spring.security.oauth2.client.provider.oauth-server.issuer-uri}/oauth2/authorize
  21.             #令牌获取地址
  22.             tokenUri: ${spring.security.oauth2.client.provider.oauth-server.issuer-uri}/oauth2/token
  23.         registration:
  24.           messaging-client-oidc:
  25.             #认证提供者，标识由哪个认证服务器进行认证，和上面的oauth-server进行关联
  26.             provider: oauth-server
  27.             #客户端名称
  28.             client-name: web平台-SSO客户端-订单服务
  29.             #客户端id，从认证平台申请的客户端id
  30.             client-id: web-client-id-order
  31.             #客户端秘钥
  32.             client-secret: secret
  33.             #客户端认证方式
  34.             client-authentication-method: client_secret_basic
  35.             #使用授权码模式获取令牌（token）
  36.             authorization-grant-type: authorization_code
  37.             #回调地址，接收认证服务器回传code的接口地址，之前我们是使用http://www.baidu.com代替
  38.             redirect-uri: http://spring-oauth-client-order:9003/login/oauth2/code/messaging-client-oidc
  39.             scope:
  40.               - profile
  41.               - openid
复制代码
oauth2_registered_client 表增加一条订单服务的客户端记载：
  1. INSERT INTO `oauth-server`.`oauth2_registered_client` (`id`, `client_id`, `client_id_issued_at`, `client_secret`, `client_secret_expires_at`, `client_name`, `client_authentication_methods`, `authorization_grant_types`, `redirect_uris`, `post_logout_redirect_uris`, `scopes`, `client_settings`, `token_settings`) VALUES ('3eacac0e-0de9-4727-9a64-6bdd4be2ee3', 'web-client-id-order', '2023-07-12 07:33:42', '$2a$10$.J0Rfg7y2Mu8AN8Dk2vL.eBFa9NGbOYCPOAFEw.QhgGLVXjO7eFDC', NULL, 'web平台-SSO客户端-订单服务', 'client_secret_basic', 'refresh_token,authorization_code', 'http://spring-oauth-client-order:9003/login/oauth2/code/messaging-client-oidc', 'http://127.0.0.1:9000/', 'openid,profile', '{"@class":"java.util.Collections$UnmodifiableMap","settings.client.require-proof-key":false,"settings.client.require-authorization-consent":true}', '{"@class":"java.util.Collections$UnmodifiableMap","settings.token.reuse-refresh-tokens":true,"settings.token.id-token-signature-algorithm":["org.springframework.security.oauth2.jose.jws.SignatureAlgorithm","RS256"],"settings.token.access-token-time-to-live":["java.time.Duration",1800.000000000],"settings.token.access-token-format":{"@class":"org.springframework.security.oauth2.server.authorization.settings.OAuth2TokenFormat","value":"self-contained"},"settings.token.refresh-token-time-to-live":["java.time.Duration",3600.000000000],"settings.token.authorization-code-time-to-live":["java.time.Duration",300.000000000],"settings.token.device-code-time-to-live":["java.time.Duration",300.000000000]}');
复制代码
商品服务搭建

商品服务作为客户端，参考前面客户端的搭建。
application.yml 设置如下：
  1. server:
  2.   ip: spring-oauth-client-product
  3.   port: 9004
  5. logging:
  6.   level:
  7.     org.springframework.security: trace
  9. spring:
  10.   application:
  11.     name: spring-oauth-client-product
  12.   security:
  13.     oauth2:
  14.       client:
  15.         provider:
  16.           #认证服务器信息
  17.           oauth-server:
  18.             #授权地址
  19.             issuer-uri: http://spring-oauth-server:9000
  20.             authorizationUri: ${spring.security.oauth2.client.provider.oauth-server.issuer-uri}/oauth2/authorize
  21.             #令牌获取地址
  22.             tokenUri: ${spring.security.oauth2.client.provider.oauth-server.issuer-uri}/oauth2/token
  23.         registration:
  24.           messaging-client-oidc:
  25.             #认证提供者，标识由哪个认证服务器进行认证，和上面的oauth-server进行关联
  26.             provider: oauth-server
  27.             #客户端名称
  28.             client-name: web平台-SSO客户端-商品服务
  29.             #客户端id，从认证平台申请的客户端id
  30.             client-id: web-client-id-product
  31.             #客户端秘钥
  32.             client-secret: secret
  33.             #客户端认证方式
  34.             client-authentication-method: client_secret_basic
  35.             #使用授权码模式获取令牌（token）
  36.             authorization-grant-type: authorization_code
  37.             #回调地址，接收认证服务器回传code的接口地址，之前我们是使用http://www.baidu.com代替
  38.             redirect-uri: http://spring-oauth-client-product:9004/login/oauth2/code/messaging-client-oidc
  39.             scope:
  40.               - profile
  41.               - openid
复制代码
oauth2_registered_client 表增加一条商品服务的客户端记载：
  1. INSERT INTO `oauth-server`.`oauth2_registered_client` (`id`, `client_id`, `client_id_issued_at`, `client_secret`, `client_secret_expires_at`, `client_name`, `client_authentication_methods`, `authorization_grant_types`, `redirect_uris`, `post_logout_redirect_uris`, `scopes`, `client_settings`, `token_settings`) VALUES ('3eacac0e-0de9-4727-9a64-6bdd4be2ee4', 'web-client-id-product', '2023-07-12 07:33:42', '$2a$10$.J0Rfg7y2Mu8AN8Dk2vL.eBFa9NGbOYCPOAFEw.QhgGLVXjO7eFDC', NULL, 'web平台-SSO客户端-商品服务', 'client_secret_basic', 'refresh_token,authorization_code', 'http://spring-oauth-client-product:9004/login/oauth2/code/messaging-client-oidc', 'http://127.0.0.1:9000/', 'openid,profile', '{"@class":"java.util.Collections$UnmodifiableMap","settings.client.require-proof-key":false,"settings.client.require-authorization-consent":true}', '{"@class":"java.util.Collections$UnmodifiableMap","settings.token.reuse-refresh-tokens":true,"settings.token.id-token-signature-algorithm":["org.springframework.security.oauth2.jose.jws.SignatureAlgorithm","RS256"],"settings.token.access-token-time-to-live":["java.time.Duration",1800.000000000],"settings.token.access-token-format":{"@class":"org.springframework.security.oauth2.server.authorization.settings.OAuth2TokenFormat","value":"self-contained"},"settings.token.refresh-token-time-to-live":["java.time.Duration",3600.000000000],"settings.token.authorization-code-time-to-live":["java.time.Duration",300.000000000],"settings.token.device-code-time-to-live":["java.time.Duration",300.000000000]}');
复制代码
单点登录测试

测试无需登录的请求
浏览器输入地址[http://spring-oauth-client-order:9003/index](http://spring-oauth- client-order:9003/index)，测试放开保护的资源，结果如下：
测试需要登录的请求
浏览器输入地址[http://spring-oauth-client-order:9003/order1](http://spring-oauth- client-order:9003/order1)，测试受保护的资源，结果如下：
输入用户：user，暗码：123456，提交登录，跳转到授权确认页面。勾选授权信息，提交确认授权，则乐成跳转到订单页面1，结果如下：
点击“跳转到商品页面1”，此时我们从订单服务跳转到商品服务，属于跨客户端服务，由于我们在利用订单服务时已经输入用户名和暗码进行了登录，session
会话已存在，因此在此处就绕过了用户名、暗码登录了。勾选授权信息，提交确认授权，则乐成跳转到订单页面1，结果如下：
在首次访问订单服务或商品服务受保护的资源时，在登录过程中，都会跳转到授权确认页面进行授权确认，如果想去掉授权确认页面的这一步利用，实现无感确认，可以将oauth2_registered_client表中对应的客户端记载，client_settings字段的settings.client.require-
authorization-consent值设置为false。将settings.client.require-authorization-
consent值设置为false后，上面的测试，首次访问商品服务进行登录时，输入用户名、暗码提交后，将不会跳转到授权确认页面，直接默认授权，从商品服务的页面首次跳转到订单服务的页面时，也不会先跳转到授权确认页面，而是直接跳转到订单服务的页面。
微服务网关整合 Oauth2 安全认证明战

实现思路

这就是网关通过认证服务获取认证信息的一个流程，根本上只需要添加设置文件即可由框架引导进行 OAuth2 认证流程。
设置授权服务器

授权服务器中注册网关客户端信息。
  1. INSERT INTO `oauth-server`.`oauth2_registered_client` (`id`, `client_id`, `client_id_issued_at`, `client_secret`, `client_secret_expires_at`, `client_name`, `client_authentication_methods`, `authorization_grant_types`, `redirect_uris`, `post_logout_redirect_uris`, `scopes`, `client_settings`, `token_settings`) VALUES ('3eacac0e-0de9-4727-9a64-6bdd4be2ee6', 'mall-gateway-id', '2023-07-12 07:33:42', '$2a$10$.J0Rfg7y2Mu8AN8Dk2vL.eBFa9NGbOYCPOAFEw.QhgGLVXjO7eFDC', NULL, '网关服务', 'client_secret_basic', 'refresh_token,authorization_code', 'http://mall-gateway:8888/login/oauth2/code/messaging-client-oidc', 'http://127.0.0.1:9000/', 'openid,profile', '{"@class":"java.util.Collections$UnmodifiableMap","settings.client.require-proof-key":false,"settings.client.require-authorization-consent":true}', '{"@class":"java.util.Collections$UnmodifiableMap","settings.token.reuse-refresh-tokens":true,"settings.token.id-token-signature-algorithm":["org.springframework.security.oauth2.jose.jws.SignatureAlgorithm","RS256"],"settings.token.access-token-time-to-live":["java.time.Duration",1800.000000000],"settings.token.access-token-format":{"@class":"org.springframework.security.oauth2.server.authorization.settings.OAuth2TokenFormat","value":"self-contained"},"settings.token.refresh-token-time-to-live":["java.time.Duration",3600.000000000],"settings.token.authorization-code-time-to-live":["java.time.Duration",300.000000000],"settings.token.device-code-time-to-live":["java.time.Duration",300.000000000]}');
复制代码
网关接入 OAuth2

网关可以作为客户端和资源服务器。
注意：Spring Cloud Gateway 网关使用的是 webflux，需要 webflux 版本的 Spring Security 支持
   官方文档：<https://docs.spring.io/spring-
security/reference/reactive/oauth2/client/index.html>
  1）引入依靠
引入 oauth2 客户端和资源服务的依靠
  1. <!--spring-boot-starter-oauth2-client-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-oauth2-client</artifactId>
  5.     <version>3.1.4</version>
  6. </dependency>
  8. <!--spring-boot-starter-oauth2-resource-server-->
  9. <dependency>
  10.     <groupId>org.springframework.boot</groupId>
  11.     <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
  12.     <version>3.1.4</version>
  13. </dependency>
复制代码
  1. spring:
  2.   security:
  3.   oauth2:
  4.     # 资源服务器配置
  5.     resourceserver:
  6.       jwt:
  7.         # Jwt中claims的iss属性，也就是jwt的签发地址，即认证服务器的根路径
  8.         # 资源服务器会进一步的配置，通过该地址获取公钥以解析jwt
  9.         issuer-uri: http://spring-oauth-server:9000
  10.     client:
  11.       provider:
  12.         #认证服务器信息
  13.         oauth-server:
  14.           #授权地址
  15.           issuer-uri: http://spring-oauth-server:9000
  16.           # 获取用户信息的地址，默认的/userinfo端点需要IdToken获取，为避免麻烦自定一个用户信息接口
  17. #            user-info-uri: ${spring.security.oauth2.client.provider.oauth-server.issuer-uri}/user
  18. #            user-name-attribute: name
  19.           authorizationUri: ${spring.security.oauth2.client.provider.oauth-server.issuer-uri}/oauth2/authorize
  20.           #令牌获取地址
  21.           tokenUri: ${spring.security.oauth2.client.provider.oauth-server.issuer-uri}/oauth2/token
  22.       registration:
  23.         messaging-client-oidc:
  24.           #认证提供者，标识由哪个认证服务器进行认证，和上面的oauth-server进行关联
  25.           provider: oauth-server
  26.           #客户端名称
  27.           client-name: 网关服务
  28.           #客户端id，从认证平台申请的客户端id
  29.           client-id: mall-gateway-id
  30.           #客户端秘钥
  31.           client-secret: secret
  32.           #客户端认证方式
  33.           client-authentication-method: client_secret_basic
  34.           #使用授权码模式获取令牌（token）
  35.           authorization-grant-type: authorization_code
  36.           #回调地址，接收认证服务器回传code的接口地址，之前我们是使用http://www.baidu.com代替
  37.           redirect-uri: http://mall-gateway:8888/login/oauth2/code/messaging-client-oidc
  38.           scope:
  39.             - profile
  40.             - openid
复制代码
3）编写网关资源服务设置
  1. /**
  2. * 资源服务器配置
  3. */
  4. @Configuration
  5. @EnableWebFluxSecurity
  6. @EnableReactiveMethodSecurity
  7. public class WebSecurityConfig {
  8.     /**
  9.      * 配置认证相关的过滤器链
  10.      *
  11.      * @param http Spring Security的核心配置类
  12.      * @return 过滤器链
  13.      */
  14.     @Bean
  15.     public SecurityWebFilterChain defaultSecurityFilterChain(ServerHttpSecurity http) {
  16.         // 全部请求都需要认证
  17.         http.authorizeExchange((authorize) -> authorize
  18.                 .anyExchange().authenticated()
  19.         );
  20.         // 开启OAuth2登录
  21.         http.oauth2Login(Customizer.withDefaults());
  23.         // 设置当前服务为资源服务，解析请求头中的token
  24.         http.oauth2ResourceServer((resourceServer) -> resourceServer
  25.                         // 使用jwt
  26.                         .jwt(Customizer.withDefaults())
  27.                 /*
  28.                 // 请求未携带Token处理
  29.                 .authenticationEntryPoint(this::authenticationEntryPoint)
  30.                 // 权限不足处理
  31.                 .accessDeniedHandler(this::accessDeniedHandler)
  32.                 // Token解析失败处理
  33.                 .authenticationFailureHandler(this::failureHandler)
  34.                 */
  35.         );
  36.         // 禁用csrf与cors
  37.         http.csrf((csrf) -> csrf.disable());
  38.         http.cors((cors)->cors.disable());
  40.         return http.build();
  41.     }
  42. }
复制代码
需要注意的是开启方法级别鉴权的注解变了，webflux 的注解和 webmvc 的注解不一样，而且过滤器链也换成
SecurityWebFilterChain 了。
4）增加令牌中继设置
注意：设置文件中令牌中继(TokenRelay)的设置就是添加一个 filter：TokenRelay=; 当网关引入 spring-boot-
starter-oauth2-client 依靠并设置 spring.security.oauth2.client.* 属性时，会自动创建一个
TokenRelayGatewayFilterFactory 过滤器，它会从认证信息中获取 access token，并放入下游请求的请求头中。
   Gateway关于TokenRelay的文档： <https://docs.spring.io/spring-cloud-
gateway/docs/current/reference/html/#the-tokenrelay-gatewayfilter-factory>
  1. spring:
  2.   cloud:
  3.     gateway:
  4.       default-filters:
  5.         # 令牌中继  会在请求头中添加token向下游传递
  6.         - TokenRelay=
复制代码
资源服务器设置

以会员微服务为例，需要调用订单微服务，都属于资源服务器。
1）引入资源服务器依靠
  1. <!--spring-boot-starter-oauth2-resource-server-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
  5.     <version>3.1.4</version>
  6. </dependency>
复制代码
2）application.yml 中添加资源服务器设置
  1. spring:
  2.     security:
  3.       oauth2:
  4.         # 资源服务器配置
  5.         resource-server:
  6.           jwt:
  7.             # Jwt中claims的iss属性，也就是jwt的签发地址，即认证服务器的根路径
  8.             # 资源服务器会进一步的配置，通过该地址获取公钥以解析jwt
  9.             issuer-uri: http://spring-oauth-server:9000
复制代码
3）设置资源服务器
  1. @Configuration
  2. @EnableWebSecurity
  3. @EnableMethodSecurity(jsr250Enabled = true, securedEnabled = true)
  4. public class ResourceServerConfig {
  6.     @Bean
  7.     SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
  9.         http.authorizeHttpRequests((authorizeHttpRequests) -> authorizeHttpRequests
  10.                         //所有的访问都需要通过身份认证
  11.                         .anyRequest().authenticated()
  12.                 )
  13.                 .oauth2ResourceServer((oauth2ResourceServer) -> oauth2ResourceServer
  14.                         .jwt(Customizer.withDefaults())
  16.                 );
  18.         return http.build();
  19.     }
  21. }
复制代码
4）添加 openFeign 拦截器
会员服务调用订单服务，token 令牌需要向下游微服务通报，可以借助 openFeign 拦截器实现
  1. @Slf4j
  2. public class FeignAuthRequestInterceptor implements RequestInterceptor {
  3.     @Override
  4.     public void apply(RequestTemplate template) {
  5.         // 业务逻辑  模拟认证逻辑
  6.         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder
  7.                 .getRequestAttributes();
  8.         if(null != attributes){
  9.             HttpServletRequest request = attributes.getRequest();
  10.             String access_token = request.getHeader("Authorization");
  11.             log.info("从Request中解析请求头:{}",access_token);
  12.             //设置token
  13.             template.header("Authorization",access_token);
  14.         }
  16.     }
  17. }
复制代码
在 application.yml 中增加 openFeign 拦截器设置
测试

访问：[http://mall-gateway:8888/user/findOrderByUserId/1](http://mall- gateway:8888/user/findOrderByUserId/1)
因为没有访问权限，会跳转到授权服务器登录界面
登录，勾选授权之后，返回如下结果：
学习资料分享

固然，只给予计划不给予学习资料的行为无异于耍流氓，### 如果你对网络安全入门感兴趣，那么你点击这里



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4