基于OAuth2.0的统一认证登录方案

Posted 2021-04-24 JAVA程序猿成长之路

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了基于OAuth2.0的统一认证登录方案相关的知识，希望对你有一定的参考价值。

主要采用的授权模式的统一认证

授权码模式（authorization code）是功能最完整、流程最严密的授权模式。它的特点就是通过客户端的后台服务器，与"服务提供商"的认证服务器进行互动。它的步骤如下：

（A）用户访问客户端，后者将前者导向认证服务器。

（B）用户选择是否给予客户端授权。

（C）假设用户给予授权，认证服务器将用户导向客户端事先指定的"重定向URI"（redirection URI），同时附上一个授权码。

（D）客户端收到授权码，附上早先的"重定向URI"，向认证服务器申请令牌。这一步是在客户端的后台的服务器上完成的，对用户不可见。

（E）认证服务器核对了授权码和重定向URI，确认无误后，向客户端发送访问令牌（access token）和更新令牌（refresh token）。

下面是上面这些步骤所需要的参数。

A步骤中，客户端申请认证的URI，包含以下参数：

response_type：表示授权类型，必选项，此处的值固定为"code"
client_id：表示客户端的ID，必选项
redirect_uri：表示重定向URI，可选项
scope：表示申请的权限范围，可选项
state：表示客户端的当前状态，可以指定任意值，认证服务器会原封不动地返回这个值。

下面是一个例子。

GET /authorize?response_type=code&client_id=s6BhdRkqt3&state=xyz
        &redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb HTTP/1.1Host: server.example.com

C步骤中，服务器回应客户端的URI，包含以下参数：

code：表示授权码，必选项。该码的有效期应该很短，通常设为10分钟，客户端只能使用该码一次，否则会被授权服务器拒绝。该码与客户端ID和重定向URI，是一一对应关系。
state：如果客户端的请求中包含这个参数，认证服务器的回应也必须一模一样包含这个参数。

下面是一个例子。

HTTP/1.1 302 FoundLocation: https://client.example.com/cb?code=SplxlOBeZQQYbYS6WxSbIA
          &state=xyz

D步骤中，客户端向认证服务器申请令牌的HTTP请求，包含以下参数：

granttype：表示使用的授权模式，必选项，此处的值固定为"authorizationcode"。
code：表示上一步获得的授权码，必选项。
redirect_uri：表示重定向URI，必选项，且必须与A步骤中的该参数值保持一致。
client_id：表示客户端ID，必选项。

下面是一个例子。

POST /token HTTP/1.1Host: server.example.comAuthorization: Basic czZCaGRSa3F0MzpnWDFmQmF0M2JWContent-Type: application/x-www-form-urlencoded

grant_type=authorization_code&code=SplxlOBeZQQYbYS6WxSbIA
&redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb

E步骤中，认证服务器发送的HTTP回复，包含以下参数：

access_token：表示访问令牌，必选项。
token_type：表示令牌类型，该值大小写不敏感，必选项，可以是bearer类型或mac类型。
expires_in：表示过期时间，单位为秒。如果省略该参数，必须其他方式设置过期时间。
refresh_token：表示更新令牌，用来获取下一次的访问令牌，可选项。
scope：表示权限范围，如果与客户端申请的范围一致，此项可省略。

下面是一个例子。


     HTTP/1.1 200 OK
     Content-Type: application/json;charset=UTF-8
     Cache-Control: no-store
     Pragma: no-cache     {       "access_token":"2YotnFZFEjr1zCsicMWpAA",       "token_type":"example",       "expires_in":3600,       "refresh_token":"tGzv3JOkF0XG5Qx2TlKWIA",       "example_parameter":"example_value"     }

从上面代码可以看到，相关参数使用JSON格式发送（Content-Type: application/json）。此外，HTTP头信息中明确指定不得缓存

案例主要采用SpringBoot+Spring Security+Spring OAuth2.0

下次代码主要介绍，如何在源码基础上返回更多的用户信息

 
   
   
 
  
    
    
  //
  
    
    
  // Source code recreated from a .class file by IntelliJ IDEA
  
    
    
  // (powered by Fernflower decompiler)
  
    
    
  //
  
    
    
  

  
    
    
  package org.springframework.boot.autoconfigure.security.oauth2.resource;
  
    
    
  

  
    
    
  import java.util.Collection;
  
    
    
  import java.util.Collections;
  
    
    
  import java.util.List;
  
    
    
  import java.util.Map;
  
    
    
  import java.util.Set;
  
    
    
  import org.apache.commons.logging.Log;
  
    
    
  import org.apache.commons.logging.LogFactory;
  
    
    
  import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  
    
    
  import org.springframework.security.core.AuthenticationException;
  
    
    
  import org.springframework.security.core.GrantedAuthority;
  
    
    
  import org.springframework.security.oauth2.client.OAuth2RestOperations;
  
    
    
  import org.springframework.security.oauth2.client.OAuth2RestTemplate;
  
    
    
  import org.springframework.security.oauth2.client.resource.BaseOAuth2ProtectedResourceDetails;
  
    
    
  import org.springframework.security.oauth2.common.DefaultOAuth2AccessToken;
  
    
    
  import org.springframework.security.oauth2.common.OAuth2AccessToken;
  
    
    
  import org.springframework.security.oauth2.common.exceptions.InvalidTokenException;
  
    
    
  import org.springframework.security.oauth2.provider.OAuth2Authentication;
  
    
    
  import org.springframework.security.oauth2.provider.OAuth2Request;
  
    
    
  import org.springframework.security.oauth2.provider.token.ResourceServerTokenServices;
  
    
    
  import org.springframework.util.Assert;
  
    
    
  

  
    
    
  public class UserInfoTokenServices implements ResourceServerTokenServices {
  
    
    
      protected final Log logger = LogFactory.getLog(this.getClass());
  
    
    
      private final String userInfoEndpointUrl;
  
    
    
      private final String clientId;
  
    
    
      private OAuth2RestOperations restTemplate;
  
    
    
      private String tokenType = "Bearer";
  
    
    
      private AuthoritiesExtractor authoritiesExtractor = new FixedAuthoritiesExtractor();
  
    
    
      private PrincipalExtractor principalExtractor = new FixedPrincipalExtractor();
  
    
    
  

  
    
    
      public UserInfoTokenServices(String userInfoEndpointUrl, String clientId) {
  
    
    
          this.userInfoEndpointUrl = userInfoEndpointUrl;
  
    
    
          this.clientId = clientId;
  
    
    
      }
  
    
    
  

  
    
    
      public void setTokenType(String tokenType) {
  
    
    
          this.tokenType = tokenType;
  
    
    
      }
  
    
    
  

  
    
    
      public void setRestTemplate(OAuth2RestOperations restTemplate) {
  
    
    
          this.restTemplate = restTemplate;
  
    
    
      }
  
    
    
  

  
    
    
      public void setAuthoritiesExtractor(AuthoritiesExtractor authoritiesExtractor) {
  
    
    
          Assert.notNull(authoritiesExtractor, "AuthoritiesExtractor must not be null");
  
    
    
          this.authoritiesExtractor = authoritiesExtractor;
  
    
    
      }
  
    
    
  

  
    
    
      public void setPrincipalExtractor(PrincipalExtractor principalExtractor) {
  
    
    
          Assert.notNull(principalExtractor, "PrincipalExtractor must not be null");
  
    
    
          this.principalExtractor = principalExtractor;
  
    
    
      }
  
    
    
  

  
    
    
      /**
  
    
    
       根据access_token获取用户认证信息（根据access_token调用认证服务器）
  
    
    
      */
  
    
    
      public OAuth2Authentication loadAuthentication(String accessToken) throws AuthenticationException, InvalidTokenException {
  
    
    
          //this.userInfoEndpointUrl application.peoperties中配置的
  
    
    
          //获取用户信息的URL security.oauth2.resource.userInfoUri
  
    
    
          //accessToken 回去的access_token
  
    
    
          //以下为根据access_token和获取用户信息的URL(需要则认证服务器写专门的controller处理)获取用户信息
  
    
    
          Map<String, Object> map = this.getMap(this.userInfoEndpointUrl, accessToken);
  
    
    
          if (map.containsKey("error")) {
  
    
    
              if (this.logger.isDebugEnabled()) {
  
    
    
                  this.logger.debug("userinfo returned error: " + map.get("error"));
  
    
    
              }
  
    
    
  

  
    
    
              throw new InvalidTokenException(accessToken);
  
    
    
          } else {
  
    
    
              return this.extractAuthentication(map);
  
    
    
          }
  
    
    
      }
  
    
    
  

  
    
    
      /**
  
    
    
       提取用户认证信息
  
    
    
      */
  
    
    
      private OAuth2Authentication extractAuthentication(Map<String, Object> map) {
  
    
    
          Object principal = this.getPrincipal(map);
  
    
    
          List<GrantedAuthority> authorities = this.authoritiesExtractor.extractAuthorities(map);
  
    
    
          OAuth2Request request = new OAuth2Request((Map)null, this.clientId, (Collection)null, true, (Set)null, (Set)null, (String)null, (Set)null, (Map)null);
  
    
    
          //将提取的值principal作为构造函数参数
  
    
    
          UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(principal, "N/A", authorities);
  
    
    
          token.setDetails(map);
  
    
    
          return new OAuth2Authentication(request, token);
  
    
    
      }
  
    
    
       /**
  
    
    
        从map中提取最终在UsernamePasswordAuthenticationToken构造函数中封装的值
  
    
    
      */
  
    
    
      protected Object getPrincipal(Map<String, Object> map) {
  
    
    
          Object principal = this.principalExtractor.extractPrincipal(map);
  
    
    
          return principal == null ? "unknown" : principal;
  
    
    
      }
  
    
    
  

  
    
    
      public OAuth2AccessToken readAccessToken(String accessToken) {
  
    
    
          throw new UnsupportedOperationException("Not supported: read access token");
  
    
    
      }
  
    
    
  

  
    
    
     /**
  
    
    
      调用认证服务器，获取用户信息
  
    
    
     */
  
    
    
      private Map<String, Object> getMap(String path, String accessToken) {
  
    
    
          if (this.logger.isDebugEnabled()) {
  
    
    
              this.logger.debug("Getting user info from: " + path);
  
    
    
          }
  
    
    
  

  
    
    
          try {
  
    
    
              OAuth2RestOperations restTemplate = this.restTemplate;
  
    
    
              if (restTemplate == null) {
  
    
    
                  BaseOAuth2ProtectedResourceDetails resource = new BaseOAuth2ProtectedResourceDetails();
  
    
    
                  resource.setClientId(this.clientId);
  
    
    
                  restTemplate = new OAuth2RestTemplate(resource);
  
    
    
              }
  
    
    
  

  
    
    
              OAuth2AccessToken existingToken = ((OAuth2RestOperations)restTemplate).getOAuth2ClientContext().getAccessToken();
  
    
    
              if (existingToken == null || !accessToken.equals(existingToken.getValue())) {
  
    
    
                  DefaultOAuth2AccessToken token = new DefaultOAuth2AccessToken(accessToken);
  
    
    
                  token.setTokenType(this.tokenType);
  
    
    
                  ((OAuth2RestOperations)restTemplate).getOAuth2ClientContext().setAccessToken(token);
  
    
    
              }
  
    
    
              //通过restTemplate返回用户信息
  
    
    
              return (Map)((OAuth2RestOperations)restTemplate).getForEntity(path, Map.class, new Object[0]).getBody();
  
    
    
          } catch (Exception var6) {
  
    
    
              this.logger.warn("Could not fetch user details: " + var6.getClass() + ", " + var6.getMessage());
  
    
    
              return Collections.singletonMap("error", "Could not fetch user details");
  
    
    
          }
  
    
    
      }
  
    
    
  }

 
   
   
 
  
    
    
  /**
  
    
    
   最终在map中提取的是什么信息，封装在principal中
  
    
    
   注意：以下只会返回一个合适的值，即使你认证服务返回在多的信息，最终都无法在客户端显示
  
    
    
  */
  
    
    
  public class FixedPrincipalExtractor implements PrincipalExtractor {
  
    
    
  

  
    
    
      //
  
    
    
      private static final String[] PRINCIPAL_KEYS = new String[] { "user", "username",
  
    
    
              "userid", "user_id", "login", "id", "name" };
  
    
    
  

  
    
    
      @Override
  
    
    
      public Object extractPrincipal(Map<String, Object> map) {
  
    
    
          //提取只会返回一个合适的值，最终封装在principal中
  
    
    
          //主要还是看认证服务器返回用户信息的接口是否返回如上数组定义的字段信息，如果没有可能会返回null
  
    
    
          for (String key : PRINCIPAL_KEYS) {
  
    
    
              if (map.containsKey(key)) {
  
    
    
                  return map.get(key);
  
    
    
              }
  
    
    
          }
  
    
    
          return null;
  
    
    
      }
  
    
    
  

  
    
    
  }

解决方案

只需要将源码中的以下代码，替换为自己想要返回的参数

 
   
   
 
  
    
    
      protected Object getPrincipal(Map<String, Object> map) {
  
    
    
          Object principal = this.principalExtractor.extractPrincipal(map);
  
    
    
          return principal == null ? "unknown" : principal;
  
    
    
      }

自己实现的代码

 
   
   
 
  
    
    
      protected Object getPrincipal(Map<String, Object> map) {
  
    
    
  

  
    
    
          CustomPrincipal customPrincipal = new CustomPrincipal();
  
    
    
  
  
    
    
          customPrincipal.setAccount((String) map.get("account"));
  
    
    
          customPrincipal.setName((String) map.get("name"));
  
    
    
          customPrincipal.setPhone((String) map.get("phone"));
  
    
    
          //and so on..
  
    
    
          return customPrincipal;
  
    
    
  

  
    
    
          /*
  
    
    
          Object principal = this.principalExtractor.extractPrincipal(map);
  
    
    
          return (principal == null ? "unknown" : principal);
  
    
    
          */
  
    
    
  

  
    
    
      }

 
   
   
 
  
    
    
  import com.alibaba.fastjson.JSONObject;
  
    
    
  

  
    
    
  /**
  
    
    
   * @author Created by niugang on 2019/1/18/20:19
  
    
    
   */
  
    
    
  public class CustomPrincipal {
  
    
    
  

  
    
    
      public CustomPrincipal() {
  
    
    
      }
  
    
    
      private String email;
  
    
    
  

  
    
    
      private String name;
  
    
    
  

  
    
    
      private String account;
  
    
    
  

  
    
    
      private String phone;
  
    
    
  

  
    
    
      //Getters and Setters
  
    
    
  
  
    
    
          return email;
  
    
    
      }
  
    
    
  

  
    
    
  
  
    
    
          this.email = email;
  
    
    
      }
  
    
    
  

  
    
    
      public String getName() {
  
    
    
          return name;
  
    
    
      }
  
    
    
  

  
    
    
      public void setName(String name) {
  
    
    
          this.name = name;
  
    
    
      }
  
    
    
  

  
    
    
      public String getAccount() {
  
    
    
          return account;
  
    
    
      }
  
    
    
  

  
    
    
      public void setAccount(String account) {
  
    
    
          this.account = account;
  
    
    
      }
  
    
    
  

  
    
    
      public String getPhone() {
  
    
    
          return phone;
  
    
    
      }
  
    
    
  

  
    
    
      public void setPhone(String phone) {
  
    
    
          this.phone = phone;
  
    
    
      }
  
    
    
  

  
    
    
       /**
  
    
    
       * 因为在principal.getName()返回的参数是字符串类型的，所以为了好处理我们需要用json用格式化一下
  
    
    
       * @return String
  
    
    
       */
  
    
    
      @Override
  
    
    
      public String toString() {
  
    
    
          JSONObject jsonObject = new JSONObject();
  
    
    
          jsonObject.put("email", this.email);
  
    
    
          jsonObject.put("name", this.name);
  
    
    
          jsonObject.put("account", this.account);
  
    
    
          jsonObject.put("phone", this.phone);
  
    
    
          return jsonObject.toString();
  
    
    
  

  
    
    
  

  
    
    
      }
  
    
    
  }

前端获取用户新 ,注意这块中的是freemarker,采坑点好久没有写freemarker一直认为springboot默认 freemarker后缀为.html,结果一直不能返回到视图，最终看了源码默认后缀为.ftl

总结：对于我们平常写代码，一丁点小知识点都不能忽略

前后调用接口获取需要显示的用户信息

 
   
   
 
  
    
    
  <script type="text/javascript">
  
    
    
  

  
    
    
      $.get("/getUserInfo", function (data) {
  
    
    
          if (data) {
  
    
    
              $("#account").html(data.account);
  
    
    
              $("#email").html(data.email);
  
    
    
              $("#name").html(data.name);
  
    
    
              $("#phone").html(data.phone);
  
    
    
          }
  
    
    
      });
  
    
    
  

  
    
    
  </script>

后台返回用户信息接口

 
   
   
 
  
    
    
      /**
  
    
    
       * @param principal 存在登录成功后的信息
  
    
    
       * @return Object
  
    
    
       */
  
    
    
      @RequestMapping({"/getUserInfo"})
  
    
    
      @ResponseBody
  
    
    
      public Object user(Principal principal) {
  
    
    
          if (principal != null) {
  
    
    
              //重写之后 principal.getName()存放是 CustomPrincipal toString形式的数据
  
    
    
              String jsonObject = principal.getName();
  
    
    
              if (jsonObject != null) {
  
    
    
                  CustomPrincipal customPrincipal = JSON.parseObject(jsonObject, CustomPrincipal.class);
  
    
    
                  return customPrincipal;
  
    
    
              }
  
    
    
          }
  
    
    
  

  
    
    
          return new Object();
  
    
    
      }

注意：以上并非全部代码，只是重点核心代码，额外的配置参考

https://gitee.com/niugangxy/springcloudAction

以上是关于基于OAuth2.0的统一认证登录方案的主要内容，如果未能解决你的问题，请参考以下文章

如何在分布式环境中搭建单点登录系统| 第二篇：基于Oauth2.0开发SSO核心代码

IT新手之路关于oauth2.0的简单理解

统一认证授权及单点登录的技术选择

实战干货！Spring Cloud Gateway 整合 OAuth2.0 实现分布式统一认证授权！

技术干货 | OAuth2.0的安全解析