职贝云数AI新零售门户

标题: 【原创精选】OAuth 2.0+JWT+spring security完成认证授权 ... [打印本页]

---

作者: 落叶数思念    时间: 2023-1-18 21:50
标题: 【原创精选】OAuth 2.0+JWT+spring security完成认证授权 ...
(, 下载次数: 0)

上传

点击文件名下载附件

(, 下载次数: 0)

上传

点击文件名下载附件

                                                                前言导读

分析一下为什么要用OAuth2和JWT来做
1. **单点登录（SSO）**方案单击登录方案是最常见的处理方案，但单点登录需求每个与用户交互的服务都必须与认证服务停止通讯，这不但会形成反复，**也会产生大量琐碎的网络流量**；
2. **分布式会话（Session）**方案经过将用户会话信息存储在共享存储中，如Redis，并运用用户会话的ID作为key来完成分布式哈希映射。当用户访问微服务时，会话数据就可以从共享存储中获取。该处理方案在高可用和扩展方面都很好，但是由于会话信息保存在共享存储中，所以需求一定的保护机制保护数据安全，因此在详细的完成中会具**有比较高的复杂度**。
3. **客户端令牌（Token）**方案令牌由客户端生成，并由认证服务器签名。在令牌中会包含足够的信息，客户端在央求时会将令牌附加在央求上，从而为各个微服务提供用户身份数据。此方案处理了分布式会话方案的安全性成绩，**但如何及时登记用户认证信息则是一个大成绩，虽然可以运用短期令牌并频繁地与认证服务器停止校验**，但并不可以彻底处理。JWT（JSON Web Tokens）是非常出名的客户端令牌处理方案，它足够简单，并且对各种环境支持程度也比较高
4. **客户端令牌与API网关结合**
经过在微服务架构中实施API网关，可以将原始的客户端令牌转换为外部会话令牌。一方面可以有效地隐藏微服务，另一方面经过API网关的一致入口可以完成令牌的登记处理。在David Borsos的第二个方案：分布式Session方案中要求开发者可以将用户会话信息单独拎出来停止集中管理。业界比较成熟的开源项目有Spring Session，其运用Redis数据库或缓存机制来完成Session存储，并经过过滤器完成Session数据的自动加载。随着近几年云服务运用的发展，基于令牌（Token）的认证运用范围也越来越广。对于基于令牌认证通常包含下面几层含义：
- 令牌是认证用户信息的集合，而不只仅是一个有意义的ID。
- 在令牌中曾经包含足够多的信息，验证令牌就可以完成用户身份的校验，从而减轻了由于用户验证需求检索数据库的压力，提升了系统功能。
- 由于令牌是需求服务器停止签名发放的，所以假如令牌经过解码认证，我们就可以以为该令牌所包含的信息是合法有效的。
- 服务器会经过HTTP头部中的Authorization获取令牌信息并停止检查，并不需求在服务器端存储任何信息。
- 经过服务器对令牌的检查机制，可以将基于令牌的认证运用在基于阅读器的客户端和移动设备的App或是第三方运用上。
·可以支持跨程序调用。基于Cookie是不允许垮域访问的，而令牌则不存在这个成绩。
综上所述，基于令牌的认证由于会包含认证用户的相关信息，因此可以经过验证令牌来完成用户身份的校验，完全不同于之前基于会话的认证。因此，基于令牌的这个优点，像T微信、支付宝、微博及GitHub等，都推出了基于令牌的认证服务，用于访问所开放的API及单点登录。接上去将重点引见基于令牌认证方案中的OAuth 2.0和JWT


                                                                各司其职
OAuth 2.0

根据官网https://oauth.net/2/ OAuth 2.0是用于授权的行业标准协议。OAuth 2.0努力于简化客户端开发人员的工作，同时为Web运用程序，桌面运用程序，移动电话和客厅设备提供特定的授权流程。该规范及其扩展正在IETF OAuth工作组内开发。
范围是OAuth 2.0中的一种机制，用于限制运用程序对用户帐户的访问。一个运用程序可以央求一个或多个范围，然后在同一 屏幕中将此信息呈现给用户，并且颁发给该运用程序的访问令牌将限于所授予的范围。
简单点说就需求两部分：

认证服务端（认证及生成token) 、认证资源服务端（访问其他服务内的资源需求校验）
为什么呢？

在如今的微服务中，一个项目能够有很多的业务服务器，假如业务服务器不受信任的时分，多个服务器之间运用相反的token对用户来说是不安全的，由于任何一个服务器拿到token都可以仿冒用户去另一个服务器处理业务，你的服务器就非常不安全。

怎样做呢？
业务服务器要想得到认证服务器的信任，就只能运用认证服务器的私钥派生的公钥来校验这个业务服务器能否有权限处理。

简单说一下怎样获取公钥

生成一个jks，放在认证服务器中

1.   keytool -genkeypair -alias kevin_key -keyalg RSA -keypass 123456 -keystore kevin_key.jks -storepass 123456

复制代码

(, 下载次数: 0)

上传

点击文件名下载附件

导出公钥

1.   keytool -list -rfc --keystore kevin_key.jks | openssl x509 -inform pem -pubkey

复制代码

保存文本public_key.txt

1.   -----BEGIN PUBLIC KEY-----
2. MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxeI6+R6DsGs5RW21Xu1Fur7iPwGjyngN3SCnwPtdR9jTrQ8EIak+gyjpI/g7gIacHIZKMlVFWoEgjQ7+hIQ5FHBrmSR/S81ezCFjYSjBbdrHYQjMRpn4mEWFmQhIyTRhg1Pb5oTUlWx+L3wc45r6JFdMOlgkKBvfo/7lzwGhxeNp10rfoJcnGDhlfZ3PmoIOYmvg7Z8UwszZpYHWf98164m3hMiPyc81iiy/DEE60OVVepyvynfBwg1aGDyA64w63FZ/2dSwfQ/7VQ7WWJb7oVoIy5pyHslWMuQJPpNCxpOgmb19AgC1GojDSL7WAEq+2gQFrb+7k4PyBdsRYzR9DQIDAQAB
3. -----END PUBLIC KEY-----

复制代码

公钥文件需求放在每个业务服务器中


(, 下载次数: 0)

上传

点击文件名下载附件

OAuth 2.0客户端授权形式

消费中普通采用授权码形式，简单来说就是你要重定向url认证服务器获取授权码（code)，在获取访问令牌。

简单画了一个流程图


(, 下载次数: 0)

上传

点击文件名下载附件

在下面流程图中第一步之后，会重定向到相似于

1. http://localhost:8080/token/oauth/authorize?client_id=client1&response_type=code&redirect_uri=/token

复制代码

会前往一个code，假设code=2
在访问

1. http://localhost:8080/oauth/token?client_id=client1&grant_type=authorization_code&redirect_uri=/token&code=2

复制代码

附加上code值，这时就会前往access_token
还有一个成绩：下面url的央求的途径需求保存在数据库中，需求新建一个表，固定的字段，不需求映射实体类，表中的一切字段必须掌握

1. CREATE TABLE `oauth_client_details` (
2.   `client_id` varchar(255) NOT NULL COMMENT '用于独一标识每一个客户端
3.   (client)；注册时必须填写(也可以服务端自动生成)，这个字段是必须的，
4.   实践运用也有叫app_key',
5.   `resource_ids` varchar(255) DEFAULT NULL COMMENT '客户端能访问的资
6.   源id集合，注册客户端时，根据实践需求可选择资源id，也可以根据不同的
7.   额注册流程，赋予对应的额资源id',
8.   `client_secret` varchar(255) DEFAULT NULL COMMENT '注册填写或者服务
9.   端自动生成，实践运用也有叫app_secret, 必需要有前缀代表加密方式',
10.   `scope` varchar(255) DEFAULT NULL COMMENT '指定client的权限范围，
11.   比如读写权限，比如移动端还是web端权限',
12.   `authorized_grant_types` varchar(255) DEFAULT NULL COMMENT '可选值
13.    授权码形式:authorization_code,密码形式:password,刷新token: refresh_token, 隐式形式: implicit: 客户端形式: client_credentials。支持多个用逗号分隔\n\n作者：输入昵称就行\n链接：',
14.   `web_server_redirect_uri` varchar(255) DEFAULT NULL COMMENT '客户端
15.   重定向uri，authorization_code和implicit需求该值停止校验，注册时填写，可为空',
16.   `authorities` varchar(255) DEFAULT NULL COMMENT '指定用户的权限范围
17.   ，假如授权的过程需求用户登陆，该字段不失效，implicit和
18.   client_credentials需求 可为空',
19.   `access_token_validity` int(11) DEFAULT NULL COMMENT '设置
20.   access_token的有效工夫(秒)默许(606012,12小时) 可空',
21.   `refresh_token_validity` int(11) DEFAULT NULL COMMENT '设置
22.   refresh_token有效期(秒)默许(606024*30, 30天) 可空',
23.   `additional_information` varchar(4096) DEFAULT NULL COMMENT '  
24.   值必须是json格式 可空',
25.   `autoapprove` varchar(255) DEFAULT NULL COMMENT '默许false,适用于
26.   authorization_code形式,设置用户能否自动approval操作,设置true跳过
27.   用户确认授权操作页面，直接跳到redirect_uri',
28.   PRIMARY KEY (`client_id`) USING BTREE
29. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

复制代码

这里给出本测试中的某些值，client1代表阅读器访问，client2代表app访问

1. INSERT INTO `oauth_client_details` VALUES ('client1', 'client1,client2', '{noop}secret1', 'app', 'authorization_code,refresh_token', '/token', NULL, 36000, 36000, NULL, 'true');
2. INSERT INTO `oauth_client_details` VALUES ('client2', 'client1,client2', '{noop}secret2', 'app', 'authorization_code,refresh_token', '/token', '', 604800, 2592000, '', 'true');

复制代码

这里还需求数据库保存授权用户，用于校验

1. CREATE TABLE `sys_user` (
2.   `id` varchar(150) NOT NULL,
3.   `phone` varchar(50) DEFAULT NULL,
4.   `email` varchar(100) DEFAULT NULL,
5.   `password` varchar(150) NOT NULL,
6.   `disable` int(11) NOT NULL,
7.   `create_time` datetime DEFAULT NULL COMMENT '创建工夫',
8.   `update_time` datetime DEFAULT NULL COMMENT '更新工夫',
9.   `ip` varchar(150) DEFAULT NULL,
10.   PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;

复制代码

    JWT
我们发现没有，我们曾经获取到了token，为什么还要有jwt呢，这就需求了解他们的生成机制。

token生成的其实就是一个UUID，和业务没有丝毫的关系，这样带来最大的成绩，就是需求人工持久化处理token（像处理分布式下的sessionId一样）。但是jwt就不需求，由于自包含，所以token里有身份验证信息，不需求做后台持久化处理，前端每次央求被保护的资源时央求头里带上该token就可以完成。
根据https://jwt.io/introduction/引见：

JSON Web令牌（JWT）是一个开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间作为JSON对象安全地传输信息。由于此信息是经过数字签名的，因此可以被验证和信任。可以运用机密（运用HMAC算法）或运用RSA或ECDSA的公钥/私钥对对JWT停止签名。
虽然可以对JWT停止加密以在单方之间提供保密性，但我们将重点关注已签名的令牌。签名的令牌可以验证其中包含的声明的残缺性，而加密的令牌则将这些声明隐藏在其他方的面前。当运用公钥/私钥对对令牌停止签名时，签名还证明只要持有私钥的一方才是对其停止签名的一方。
什么时分应该运用JSON Web令牌？

以下是JSON Web令牌有用的一些状况：

• 授权：这是运用JWT的最常见方案。一旦用户登录，每个后续央求将包括JWT，从而允许用户访问该令牌允许的路由，服务和资源。单一登录是当今广泛运用JWT的一项功能，由于它的开支很小并且可以在不同的域中轻松运用。
  
• 信息交换：JSON Web令牌是在各方之间安全地传输信息的好方法。由于可以对JWT停止签名（例如，运用公钥/私钥对），所以您可以确定发件人是他们所说的人。另外，由于签名是运用标头和有效负载计算的，因此您还可以验证内容能否未被篡改。
  

JSON Web令牌结构是什么？

JSON Web令牌以紧凑的方式由三部分组成，这些部分由点（.）分隔，分别是：

• 标头
  
• 有效载荷
  
• 签名
  

标头

标头通常由两部分组成：令牌的类型（即JWT）和所运用的签名算法，例如HMAC SHA256或RSA。
例如：

1. {
2.   "alg": "HS256",
3.   "typ": "JWT"
4. }

复制代码

有效载荷

令牌的第二部分是有效负载，其中包含声明。声明是有关实体（通常是用户）和其他数据的声明。索赔有以下三种类型：注册的，公共的和公家索赔。

• 已注册的权益要求：这些是一组非强迫性的但建议运用的预定义权益要求，以提供一组有用的，可互操作的权益要求。其中一些是： iss（发出者）， exp（到期工夫）， sub（主题）， aud（受众）等。
  请留意，声明称号仅是三个字符，由于JWT是紧凑的。
  
• 公共声明：运用JWT的人可以随意定义这些声明。但是为避免冲突，应在 IANA JSON Web令牌注册表中定义它们，或将其定义为包含抗冲突称号空间的URI。
  
• 公家权益：这些都是运用它们赞同并既不是当事人之间建立共享信息的自定义声明注册或公众的权益要求。
  

有效负载示例能够是：

1. {
2.   "sub": "1234567890",
3.   "name": "John Doe",
4.   "admin": true
5. }

复制代码

请留意，对于已签名的令牌，此信息虽然可以防止篡改，但任何人都可以读取。除非将其加密，否则请勿将机密信息放入JWT的有效负载或报头元素中。

签名

要创建签名部分，您必须获取编码的标头，编码的有效载荷，机密，标头中指定的算法，并对其停止签名。
例如，假如要运用HMAC SHA256算法，则将经过以下方式创建签名：

1. HMACSHA256(
2.   base64UrlEncode(header) + "." +
3.   base64UrlEncode(payload),
4.   secret)

复制代码

签名用于验证音讯在整个过程中没有更改，并且对于运用私钥停止签名的令牌，它还可以验证JWT的发送者是它所说的真实身份。
下图显示了一个JWT，它已对先前的标头和有效负载停止了编码，并用一个机密停止了签名。
假如您想运用JWT并将这些概念付诸实际，则可以运用http://jwt.io Debugger解码，验证和生成JWT。

(, 下载次数: 0)

上传

点击文件名下载附件

                                                ​


JWT运用
之前我们说了，我们需求将UUID的token转换成有用户信息的JWT token，才不需求身份的验证，怎样样去获取UUID的token呢？怎样去获取用户数据呢？
首先讲讲怎样获取用户信息, 在登录时，将央求到
http://172.16.xx.xx:9999/AUTH/auth/login
留意参数是固定格式，不可修正（username，password）deviceType代表是APP还是阅读器自定义

1. private JSONObject requestToken(String account, String password, String deviceType) {
2.         String result = null;
3.         try {
4.             RestTemplate restTemplate = new RestTemplate();
5.             HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
6.             HttpClient httpClient = HttpClientBuilder.create().setRedirectStrategy(new LaxRedirectStrategy()).build();
7.             factory.setHttpClient(httpClient);
8.             restTemplate.setRequestFactory(factory);
9. ​
10. ​
11.             MultiValueMap<String, Object> sendMap = new LinkedMultiValueMap<>();
12.             sendMap.add("username", account);
13.             sendMap.add("password", password);
14.             result = RestTemplateUtil.postForEntityFormData(restTemplate, http://172.16.xx.xx:9999/AUTH/auth/login, sendMap, deviceType);
15.             logger.info("认证中心前往结果-------》》》》》" + result);
16.         } catch (Exception e) {
17.             logger.error("error", e);
18.             throw new Exception("500", e);
19.         }
20.         return JSON.parseObject(result);
21.     }

复制代码

WebSecurityConfigurerAdapter 将会阻拦到这个央求，获取到username
根据username获取到用户的详细信息，并经过userDetailsService()检验能否有当前用户的信息,留意这个方法前往了UserDetails，阐明UserDetails里有数据了，方便我们获取要添加的userId字段。这里还需求留意：configure方法第一个用于配置用户来源于数据库，第二个配置途径阻拦，successHandler重定向url

1. package org.xx.distributed.auth.conf.auth;
2. ​
3. import javax.transaction.Transactional;
4. ​
5. import org.bifu.distributed.auth.constant.AuthContants;
6. import org.bifu.distributed.auth.dao.UserMapper;
7. import org.bifu.distributed.auth.domain.User;
8. import org.bifu.distributed.auth.dto.SecurityUserDTO;
9. import org.slf4j.Logger;
10. import org.slf4j.LoggerFactory;
11. import org.springframework.beans.factory.annotation.Autowired;
12. import org.springframework.context.annotation.Bean;
13. import org.springframework.context.annotation.Configuration;
14. import org.springframework.security.authentication.AuthenticationManager;
15. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
16. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
17. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
18. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
19. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
20. import org.springframework.security.core.userdetails.UserDetails;
21. import org.springframework.security.core.userdetails.UserDetailsService;
22. import org.springframework.security.core.userdetails.UsernameNotFoundException;
23. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
24. ​
25. @Configuration
26. @EnableGlobalMethodSecurity(prePostEnabled = true)
27. @EnableWebSecurity
28. public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
29.   
30.   private final static Logger logger = LoggerFactory.getLogger(SecurityConfiguration.class);
31. ​
32.   @Autowired
33.   private UserMapper userMapper;
34. ​
35.   @Autowired
36.   private MyAuthenticationSuccessHandler myAuthenticationSuccessHandler;
37. ​
38.   @Autowired
39.   private MyAuthenticationFailureHandler myAuthenticationFailureHandler;
40. ​
41.   @Autowired
42.   public void globalUserDetails(AuthenticationManagerBuilder auth) throws Exception {
43.     // 配置用户来源于数据库
44. //    auth.userDetailsService(userDetailsService()).passwordEncoder(new MyPasswordEncoder());
45.     auth.userDetailsService(userDetailsService()).passwordEncoder(new BCryptPasswordEncoder());
46. //    auth.userDetailsService(userDetailsService()).passwordEncoder(PasswordEncoderFactories.createDelegatingPasswordEncoder());
47. //    auth.userDetailsService(userDetailsService()).passwordEncoder(MyPasswordEncoderFactories.createDelegatingPasswordEncoder());
48.   }
49. ​
50.   /**
51.    * authorizeRequests()配置途径阻拦，表明途径访问所对应的权限，角色，认证信息。
52.    * formLogin()对应表单认证相关的配置
53.    * logout()对应了登记相关的配置
54.    * httpBasic()可以配置basic登录
55.    *  配置登陆页/login并允许访问
56.    * 由于运用的是JWT，我们这里不需求csrf
57.    * @param http
58.    * @throws Exception
59.    */
60.   @Override
61.   protected void configure(HttpSecurity http) throws Exception {
62.     http.formLogin().loginProcessingUrl("/auth/login").successHandler(myAuthenticationSuccessHandler)
63.         .failureHandler(myAuthenticationFailureHandler)
64.         .and().csrf().disable()
65.         .sessionManagement()
66.         .maximumSessions(1).expiredUrl("/expiredSession");
67.   }
68. ​
69.   @Override
70.   @Bean
71.   public AuthenticationManager authenticationManagerBean() throws Exception {
72.     return super.authenticationManagerBean();
73.   }
74. ​
75.   /**
76.    * 用户验证
77.    * @return
78.    */
79.   @Override
80.   @Bean
81.   public UserDetailsService userDetailsService() {
82.     return new UserDetailsService() {
83.       @Override
84.       @Transactional(rollbackOn = Exception.class)
85.       public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
86.         logger.info("登录手机号或邮箱：======"+username);
87.         // 查用户
88.         User user = userMapper.selectByPhoneOrEmail(username, username);
89.         if (user == null) {
90.           throw new UsernameNotFoundException(AuthContants.USER_NOT_EXIST);
91.         }
92.         SecurityUserDTO dto = new SecurityUserDTO();
93.         dto.setId(user.getId());
94.         dto.setUsername(username);
95.         dto.setPassword(user.getPassword());
96.         dto.setDisable(user.getDisable());
97.         // 创建securityUserDTO
98. //        SecurityUserDTO securityUserDTO = new SecurityUserDTO(user);
99.         return dto;
100.       }
101.     };
102.   }
103. ​
104. }

复制代码

这里给出successHandler代码

1. import java.io.IOException;
2. ​
3. ​
4. import javax.servlet.ServletException;
5. import javax.servlet.http.HttpServletRequest;
6. import javax.servlet.http.HttpServletResponse;
7. ​
8. ​
9. import org.bifu.distributed.auth.constant.AuthContants;
10. import org.slf4j.Logger;
11. import org.slf4j.LoggerFactory;
12. import org.springframework.beans.factory.annotation.Value;
13. import org.springframework.security.core.Authentication;
14. import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
15. import org.springframework.stereotype.Component;
16. ​
17. ​
18. @Component
19. public class MyAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
20.     private final static Logger logger = LoggerFactory.getLogger(MyAuthenticationSuccessHandler.class);
21. ​
22. ​
23.     @Value(value = "${prefix.auth}")
24.     private String authPrefix; // /token
25. ​
26. ​
27.     @Value(value = "${oauth.redirectUrl}")
28.     private String redirectUrl; // /token
29. ​
30. ​
31.     @Override
32.     public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
33.             Authentication authentication) throws IOException, ServletException {
34.         String deviceType = request.getHeader("deviceType");
35.         logger.info("访问设备-----------》》》" + deviceType);
36.         if (deviceType == null || "".equals(deviceType)) {
37.             deviceType = "browser";
38.         }
39.         // 重定向url到 /token 接口
40.         if ("browser".equals(deviceType)) {
41.             response.sendRedirect("http://localhost:8080:oauth/authorize?client_id=client1&response_type=code&redirect_uri=/token");
42.         } else if ("app".equals(deviceType)) {
43.             response.sendRedirect(http://localhost:8080:oauth/authorize?client_id=client2&response_type=code&redirect_uri=/token);
44.         }
45.     }
46. ​
47. ​
48. }

复制代码

重定向到这个接口

1. /**
2.      * 授权，登录
3.      */
4.     @ResponseBody
5.     @RequestMapping(value = "/token")
6.     public ResultDTO<TokenResultDTO> token(HttpServletRequest request, HttpServletResponse response,
7.             RedirectAttributes attributes) {
8.         logger.info("预备获取token, 获取code = {}", request.getParameter("code"));
9.         TokenResultDTO result = this.userService.token(attributes, request, response);
10.         logger.info("获取到token= {}", JSONObject.toJSONString(result));
11.         return new ResultDTO<TokenResultDTO>(AuthContants.CODE_200, AuthContants.KEYWORD_SUCCESS, result);
12.     }

复制代码

token方法，这里需求留意一个点，这里前往参数李获取的userId就是UserDetails设置的userId

1. public TokenResultDTO token(RedirectAttributes attributes, HttpServletRequest request,
2.             HttpServletResponse response) {
3.         try {
4. ​
5. ​
6.             String code = request.getParameter("code");
7.             if (StringUtils.isEmpty(code)) {
8.                 throw new BusinessException(AuthContants.CODE_EXCEPTION);
9.             }
10.             // 发送央求token
11.             String deviceType = "browser";
12.             if (request.getHeader("deviceType") != null && !"".equals(request.getHeader("deviceType"))) {
13.                 deviceType = request.getHeader("deviceType");
14.             }
15.             HttpHeaders headers = new HttpHeaders();
16.             HttpEntity<String> entity = new HttpEntity<String>(headers);
17.             TokenResultDTO tokenResultDTO = null;
18.             if ("browser".equals(deviceType)) {
19.                 tokenResultDTO = this.browserRestTemplate.postForObject(
20.                        " http://localhost/oauth/token?client_id=client1&grant_type=authorization_code&redirect_uri=/token&code=" + code,
21.                         entity, TokenResultDTO.class);
22.             } else if ("app".equals(deviceType)) {
23.                 tokenResultDTO = this.appRestTemplate.postForObject(
24.                          " http://localhost/oauth/token?client_id=client2&grant_type=authorization_code&redirect_uri=/token&code=" + code,
25.                         entity, TokenResultDTO.class);
26.             }
27. ​
28. ​
29.             return new TokenResultDTO(tokenResultDTO.getAccess_token(), tokenResultDTO.getRefresh_token(),
30.                     tokenResultDTO.getUserId(), tokenResultDTO.getExpires_in());
31.         } catch (BusinessException e) {
33.             logger.error("token?");
34.             throw new Exception("500", e.getMessage());
35.         } catch (Exception e) {
37.             logger.error("token?");
38.             throw new Exception("500", e.getMessage());
39.         }
40.     }

复制代码

我们获取token之前，然后我们需求加强token,让前往的数据添加一个userId字段

(, 下载次数: 0)

上传

点击文件名下载附件

贴一下认证服务器的代码：

1. package org.xx.distributed.auth.conf.auth;
2. ​
3. import java.util.HashMap;
4. import java.util.Map;
5. ​
6. import javax.sql.DataSource;
7. ​
8. import com.alibaba.fastjson.JSONObject;
9. import org.bifu.distributed.auth.constant.AuthContants;
10. import org.bifu.distributed.auth.dto.SecurityUserDTO;
11. import org.slf4j.Logger;
12. import org.slf4j.LoggerFactory;
13. import org.springframework.beans.factory.annotation.Autowired;
14. import org.springframework.context.annotation.Bean;
15. import org.springframework.context.annotation.Configuration;
16. import org.springframework.core.io.ClassPathResource;
17. import org.springframework.security.authentication.AuthenticationManager;
18. import org.springframework.security.oauth2.common.DefaultOAuth2AccessToken;
19. import org.springframework.security.oauth2.common.OAuth2AccessToken;
20. import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
21. import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
22. import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
23. import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
24. import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
25. import org.springframework.security.oauth2.provider.ClientDetailsService;
26. import org.springframework.security.oauth2.provider.OAuth2Authentication;
27. import org.springframework.security.oauth2.provider.client.JdbcClientDetailsService;
28. import org.springframework.security.oauth2.provider.token.TokenStore;
29. import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
30. import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
31. import org.springframework.security.oauth2.provider.token.store.KeyStoreKeyFactory;
32. ​
33. /**
34. * 认证授权服务端
35. *
36. */
37. @Configuration
38. @EnableAuthorizationServer
39. public class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter {
40. ​
41.     private final static Logger logger = LoggerFactory.getLogger(AuthorizationServerConfiguration.class);
42. ​
43.     @Autowired
44.     private AuthenticationManager authenticationManager;
45. ​
46.     @Autowired
47.     private DataSource dataSource;
48. ​
49.     @Override
50.     public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
51.         endpoints.authenticationManager(this.authenticationManager);
52.         endpoints.accessTokenConverter(accessTokenConverter());
53.         endpoints.tokenStore(tokenStore());
54.         endpoints.reuseRefreshTokens(false);
55.     }
56. ​
57.     @Override
58.     public void configure(AuthorizationServerSecurityConfigurer oauthServer) throws Exception {
59.         oauthServer.tokenKeyAccess("isAnonymous() || hasAuthority('ROLE_TRUSTED_CLIENT')");
60.         oauthServer.checkTokenAccess("hasAuthorityhasAuthority('ROLE_TRUSTED_CLIENT')");
61.     }
62. ​
63.     @Override
64.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
65.         // jdbc方式 获取配置信息，oauth_client_details给谁发令牌，有效工夫、授权形式、刷新令牌等等
66.         clients.withClientDetails(clientDetails());
67.     }
68. ​
69.     /**
70.      * token converter
71.      *
72.      * @return
73.      */
74.     @Bean
75.     public JwtAccessTokenConverter accessTokenConverter() {
76.         JwtAccessTokenConverter accessTokenConverter = new JwtAccessTokenConverter() {
77.             /***
78.              * 重写加强token方法,用于自定义一些token前往的信息
79.              */
80.             @Override
81.             public OAuth2AccessToken enhance(OAuth2AccessToken accessToken,
82.                     OAuth2Authentication authentication) {
83.               SecurityUserDTO securityUserDTO =
84.                       (SecurityUserDTO) authentication.getUserAuthentication().getPrincipal(); //获取当前用户信息
85.                 logger.info("重写加强token方法= {}", JSONObject.toJSONString(securityUserDTO));
86.               final Map<String, Object> additionalInformation = new HashMap<>(16);
87.               additionalInformation.put("userId", securityUserDTO.getId());
88.                 // 将用户信息添加到token额外信息中
89.               ((DefaultOAuth2AccessToken) accessToken)
90.                   .setAdditionalInformation(additionalInformation);
91.                 OAuth2AccessToken enhancedToken = super.enhance(accessToken, authentication);
92.                 return enhancedToken;
93.             }
94.         };
95.         // 非对称加密
96.         KeyStoreKeyFactory keyStoreKeyFactory =
97.                 new KeyStoreKeyFactory(new ClassPathResource(AuthContants.JKS_FILE),
98.                     AuthContants.JKS_PASSWORD.toCharArray());
99.         accessTokenConverter.setKeyPair(keyStoreKeyFactory.getKeyPair(AuthContants.JKS_NAME));
100.         return accessTokenConverter;
101.     }
102. ​
103.     /**
104.      * 定义clientDetails存储的方式-》Jdbc的方式，注入DataSource
105.      *
106.      * @return
107.      */
108.     @Bean
109.     public ClientDetailsService clientDetails() {
110.         return new JdbcClientDetailsService(dataSource);
111.     }
112. ​
113.     /**
114.      * token store
115.      * 前往jwt格式token
116.      * @param
117.      * @return
118.      */
119.     @Bean
120.     public TokenStore tokenStore() {
121.         TokenStore tokenStore = new JwtTokenStore(accessTokenConverter());
122.         return tokenStore;
123.     }
124. ​
125. }

复制代码

在加强方法中我们看到
additionalInformation.put("userId", securityUserDTO.getId());
曾经将userId添加到token额外信息中，但是SecurityUserDTO 是怎样来的呢？

1. public OAuth2AccessToken enhance(OAuth2AccessToken accessToken,
2.                     OAuth2Authentication authentication)
3. {
4.               SecurityUserDTO securityUserDTO =
5.                       (SecurityUserDTO) authentication.getUserAuthentication().getPrincipal();

复制代码

可以看到SecurityUserDTO 是经过OAuth2Authentication获取的，但是
OAuth2Authentication怎样获取数据的呢？
贴出部分代码 SecurityUserDTO

1. public class SecurityUserDTO implements UserDetails {
2. ​
3.   private static final long serialVersionUID = 1L;
4. ​
5.   private String id;
6.   
7.   private String username;
8. ​
9.   private String password;
10. ​
11.   private Integer disable;
12. ​
13.     private Collection<? extends GrantedAuthority> authorities;
14. ​
15.   public SecurityUserDTO() {
16.   }

复制代码

我们进入UserDetails 查看一下源码

1. /**
2. * Provides core user information.
3. *
4. * <p>
5. * Implementations are not used directly by Spring Security for security purposes. They
6. * simply store user information which is later encapsulated into {@link Authentication}
7. * objects. This allows non-security related user information (such as email addresses,
8. * telephone numbers etc) to be stored in a convenient location.
9. * <p>
10. * Concrete implementations must take particular care to ensure the non-null contract
11. * detailed for each method is enforced. See
12. * {@link org.springframework.security.core.userdetails.User} for a reference
13. * implementation (which you might like to extend or use in your code).
14. *
15. * @see UserDetailsService
16. * @see UserCache
17. *
18. / ** *提供核心用户信息。* * <p> *出于安全目的，Spring Security不会
19. 直接运用完成。它们*仅存储用户信息，这些信息随后封装在{@link
20. Authentication} *对象中。这允许将与安全有关的用户信息（例如电子邮件
21. 地址，*电话号码等）存储在方便的地位。* <p> *详细完成必须格外小心
22. ，以确保为每个方法强迫执行详细的非空合同。请参阅* {@link org.
23. springframework.security.core.userdetails.User}以获取参考*完成
24. （您能够希望扩展或在代码中运用）。* * @请参阅UserDetailsService
25. * @请参阅UserCache *

复制代码

看到这句话：仅存储用户信息，这些信息随后封装在{@link Authentication} *对象中，我们就明白了吧，其真实后面说到的用户校验中，我们设置了UserDetails
并且它将信息存储到了Authentication中。

1. public Authentication getUserAuthentication() {
2. return userAuthentication;
3. }

复制代码

就可以获取到用户信息了吧。完美！！！

好了，到这一步我们就完成了JWT对token的加强，那么怎样保证安全性呢？

OAuth2提供了JwtAccessTokenConverter完成，添加jwtSigningKey，以此生成秘钥，以此停止签名

1. // 非对称加密
2.         KeyStoreKeyFactory keyStoreKeyFactory =
3.                 new KeyStoreKeyFactory(new ClassPathResource("kevin_key.jks"),
4.                     "123456".toCharArray());
5.         accessTokenConverter.setKeyPair(keyStoreKeyFactory.getKeyPair("kevin_key"));
6.         return accessTokenConverter;

复制代码

到这里基本上就差不多了，贴上一个打印的日志，分析一下整个流程


(, 下载次数: 0)

上传

点击文件名下载附件

                                                                   总结
经过日志可以出

• 用户输入账号、密码，央求/auth/login到认证服务器
  
• 认证服务器根据username检验用户，存放全局UserDetails
  
• 认证服务器阻拦央求判别能否合法，假如合法进入successHandler停止url重定向
  
• 重定向获取的code值继续访问/token，这时JWT会对token添加，添加我们需求前往给前段的字段
  
• 获得access_token和需求的字段
  

当前代码托管到我的Gitee :
https://gitee.com/ran_song/Limit

欢迎指正交流哦！！  
欢迎关注我的微信公众号<搜索：汀雨笔记>，会首发一些最新文章哦！
下面是我的个人网站：http://ransongv587.com
原文链接：

---

作者: CQPs1KQn    时间: 2023-1-18 21:50
这么专业，真是学习了哈，以后多多指教

---

作者: 98kqiX    时间: 2023-1-18 21:50
有没有刷新token？

---

作者: kM2ugqWV    时间: 2023-1-18 21:51
正在备稿中ing[赞同]

---

作者: B5tmA    时间: 2023-1-18 21:51
大佬，gitee上貌似没有这部分代码

---

作者: 16hxxW4    时间: 2023-1-18 21:51
换到github上了哈，关注下公众号

---

欢迎光临 职贝云数AI新零售门户 (https://www.taojin168.com/cloud/)

Powered by Discuz! X3.5