JWT认证鉴权

柔情只为你懂 2022-06-06 06:07 373阅读 0赞

# 写在前面 #

作为从业了十多年的IT行业和程序的老司机，今天如果你说你不懂微服务，都不好意思说自己的做软件的。SOA喊了多年，无人不知，但又有多少系统开发真正的SOA了呢？但是好像一夜之间所有人都投入了微服务的怀抱。

作为目前最主流的“微服务框架”，Spring Cloud发展速度很快，成为了最全面的微服务解决方案。不管什么软件体系，什么框架，安全永远是不可能绕开的话题，我也把它作为我最近一段时间研究微服务的开篇。

老话题！“如何才能在微服务体系中保证安全？”，为了达成目标，这里采用一个简单而可行方式来保护`Spring Cloud`中服务的安全，也就是建立统一的用户授权中心。

这里补充说一下什么是`Authentication（认证）`和`Authorization（鉴权）`，其实很简单，认证关心你是谁，鉴权关心你能干什么。举个大家一致都再说的例子，如果你去机场乘机，你持有的护照代表你的身份，这是认证，你的机票就是你的权限，你能干什么。

学习微服务并不是一个简单的探索过程，这不得学习很多新的知识，其实不管是按照DDD（Domain Driven Design）领域驱动设计中领域模型的方式，还是将微服务拆分成更小的粒度。都会遇到很多新的问题和以前一直都没解决很好的问题。随着不断的思考，随着熟悉`Facebook/GitHub/AWS`这些机构是如何保护内部资源，答案也逐渐浮出水面。

为了高效的实现这个目标，这里采用`OAuth 2`和`JWT(JSON Web Tokens)`技术作为解决方案。

# 为什么是JWT #

`   OAuth 2`并不关心去哪找`Access Token`和把它存在什么地方的，生成随机字符串并保存`Token`相关的数据到这些字符串中保存好。通过一个令牌端点，其他服务可能会关心这个`Token`是否有效，它可以通过哪些权限。这就是用户信息URL方法，授权服务器为了获取用户信息转换为资源服务器。

当我们谈及微服务时，我们需要找一个`Token`存储的方式，来保证授权服务器可以被水平扩展，尽管这是一个很复杂的任务。所有访问微服务资源的请求都在Http Header中携带`Token`，被访问的服务接下来再去请求授权服务器验证`Token`的有效性，目前这种方式，我们需要两次或者更多次的请求，但这是为了安全性也没什么其他办法。但扩展`Token`存储会很大影响我们系统的可扩展性，这是我们引入`JWT（读jot）`的原因。

+-----------+ +-------------+ | | 1-Request Authorization | | | |------------------------------------>| | | | grant_type&username&password | |--+ | | |Authorization| | 2-Gen | Client | |Service | | JWT | | 3-Response Authorization | |<-+ | |<------------------------------------| Private Key | | | access_token / refresh_token | | | | token_type / expire_in / jti | | +-----------+ +-------------+

简短来说，响应一个用户请求时，将用户信息和授权范围序列化后放入一个JSON字符串，然后使用Base64进行编码，最终在授权服务器用`私钥`对这个字符串进行签名，得到一个`JSON Web Token`，我们可以像使用`Access Token`一样的直接使用它，假设其他所有的资源服务器都将持有一个RSA公钥。当资源服务器接收到这个在Http Header中存有`Token`的请求，资源服务器就可以拿到这个`Token`，并验证它是否使用正确的私钥签名（是否经过授权服务器签名，也就是`验签`）。`验签`通过，反序列化后就拿到`OAuth 2`的验证信息。

验证服务器返回的信息可以是以下内容：

*  access\_token - 访问令牌，用于资源访问
 *  refresh\_token - 当访问令牌失效，使用这个令牌重新获取访问令牌
 *  token\_type - 令牌类型，这里是`Bearer`也就是基本HTTP认证
 *  expire\_in - 过期时间
 *  jti - JWT ID

由于`Access Token`是`Base64编码`，反编码后就是下面的格式，标准的JWT格式。也就是`Header`、`Payload`、`Signature`三部分。

{ "alg":"RS256", "typ":"JWT" } { "exp": 1492873315, "user_name": "reader", "authorities": [ "AURH_READ" ], "jti": "8f2d40eb-0d75-44df-a8cc-8c37320e3548", "client_id": "web_app", "scope": [ "FOO" ] } &:lƧs)ۡ-[+ F"2"Kآ8ۓٞ:u9ٴ̯ޡ 9Q32Zƌ޿$ec{ 3mxJh0DF庖[!뀭N)㥔knVVĖV|夻ׄE㍫}Ŝf9>'<蕱굤Bۋеϵov虀DӨ8C4K}Emޢ YVcaqIW&*uʝub!׏*Ť\՟-{ʖX܌WTq

使用JWT可以简单的传输`Token`，用`RSA签名`保证`Token`很难被伪造。`Access Token`字符串中包含用户信息和权限范围，我们所需的全部信息都有了，所以不需要维护`Token`存储，资源服务器也不必要求`Token`检查。

+-----------+ +-----------+ | | 1-Request Resource | | | |----------------------------------->| | | | Authorization: bearer Access Token | |--+ | | | Resource | | 2-Verify | Client | | Service | | Token | | 3-Response Resource | |<-+ | |<-----------------------------------| Public Key| | | | | +-----------+ +-----------+

所以，在微服务中使用`OAuth 2`，不会影响到整体架构的可扩展性。淡然这里还有一些问题没有涉及，例如`Access Token`过期后，使用`Refresh Token`到认证服务器重新获取`Access Token`等，后面会有具体的例子来展开讨论这些问题。

# JWT认证 鉴权DEMO #

##   项目结构如下： ##

![Image 1][]

![Center][]

##    首先需要pom.xml中添加如下依赖： ##

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <groupId>com.xt</groupId>
       <artifactId>tutorial</artifactId>
       <packaging>war</packaging>
       <version>0.0.1-SNAPSHOT</version>
       <name>tutorial Maven Webapp</name>
       <url>http://maven.apache.org</url>
       <dependencies>
          <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>3.8.1</version>
             <scope>test</scope>
          </dependency>
    
           <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-core</artifactId>
             <version>${spring.version}</version>
          </dependency>
    
           <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-beans</artifactId>
             <version>${spring.version}</version>
          </dependency>
    
           <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
             <version>${spring.version}</version>
          </dependency>
    
           <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context-support</artifactId>
             <version>${spring.version}</version>
          </dependency>
    
           <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-web</artifactId>
             <version>${spring.version}</version>
          </dependency>
    
           <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
             <version>${spring.version}</version>
          </dependency>
    
           <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
             <version>${jackson.version}</version>
          </dependency>
    
           <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
             <version>${jackson.version}</version>
          </dependency>
    
          <dependency>
             <groupId>com.auth0</groupId>
             <artifactId>java-jwt</artifactId>
             <version>${java.jwt.version}</version>
          </dependency>
    
       </dependencies>
    
       <build>
          <finalName>tutorial</finalName>
           <plugins>
             <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>8.1.16.v20140903</version>
             </plugin>
          </plugins>
       </build>
    
       <properties>
          <spring.version>4.3.2.RELEASE</spring.version>
          <jackson.version>2.8.3</jackson.version>
          <java.jwt.version>2.2.0</java.jwt.version>
       </properties>
    </project>

## 然后创建工具类JWT： ##

package com.xt.tutorial.utils;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import com.auth0.jwt.JWTSigner;
    import com.auth0.jwt.JWTVerifier;
    import com.auth0.jwt.internal.com.fasterxml.jackson.databind.ObjectMapper;
    
    public class JWT {
    
       private static final String SECRET = "XX#$%()(#*!()!KL<><MQLMNQNQJQK sdfkjsdrow32234545fdf>?N<:{LWPW";
       
       private static final String EXP = "exp";
       
       private static final String PAYLOAD = "payload";
    
       /** * get jwt String of object * @param object * the POJO object * @param maxAge * the milliseconds of life time * @return the jwt token */ public static <T> String sign(T object, long maxAge) {
          try {
             final JWTSigner signer = new JWTSigner(SECRET);
             final Map<String, Object> claims = new HashMap<String, Object>();
             ObjectMapper mapper = new ObjectMapper();
             String jsonString = mapper.writeValueAsString(object);
             claims.put(PAYLOAD, jsonString);
             claims.put(EXP, System.currentTimeMillis() + maxAge);
             return signer.sign(claims);
          } catch(Exception e) {
             return null;
          }
       }
       
       
       /** * get the object of jwt if not expired * @param jwt * @return POJO object */ public static<T> T unsign(String jwt, Class<T> classT) {
          final JWTVerifier verifier = new JWTVerifier(SECRET);
           try {
             final Map<String,Object> claims= verifier.verify(jwt);
             if (claims.containsKey(EXP) && claims.containsKey(PAYLOAD)) {
                long exp = (Long)claims.get(EXP);
                long currentTimeMillis = System.currentTimeMillis();
                if (exp > currentTimeMillis) {
                   String json = (String)claims.get(PAYLOAD);
                   ObjectMapper objectMapper = new ObjectMapper();
                   return objectMapper.readValue(json, classT);
                }
             }
             return null;
          } catch (Exception e) {
             return null;
          }
       }
    }

## 创建登录用的UsersController类，登录成功后返回tocken： ##

package com.xt.tutorial.v1.controllers;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import com.xt.tutorial.models.User;
    import com.xt.tutorial.utils.JWT;
    import com.xt.tutorial.utils.ResponseData;
    
    @Controller
    @RequestMapping("/users")
    public class UsersController {
    
       @PostMapping("/login")
       @ResponseBody
       public ResponseData login(@RequestParam String username, @RequestParam String password) {
          if ("admin".equals(username) && "123456".equals(password)) {
             ResponseData responseData = ResponseData.ok();
             User user = new User();
             user.setId(1);
             user.setUsername(username);
             user.setPassword(password);
             responseData.putDataValue("user", user);
             String token = JWT.sign(user, 30L * 24L * 3600L * 1000L);
             if (token != null) {
                responseData.putDataValue("token", token);
             }
             return responseData;
          }
          return ResponseData.customerError().putDataValue(ResponseData.ERRORS_KEY, new String[] { "用户名或者密码错误" });
       }
    }

## 为了验证我们的JWT是否真的可以工作，我们再设计一个MeController里面有一个get\_info接口： ##

##     ##

package com.xt.tutorial.v1.controllers;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import com.xt.tutorial.models.User;
    import com.xt.tutorial.utils.JWT;
    import com.xt.tutorial.utils.ResponseData;
    
    @Controller
    @RequestMapping("/me")
    public class MeController {
    
       @GetMapping("/get_info")
       @ResponseBody
       public ResponseData getInfo(@RequestParam String token) {
          User user = JWT.unsign(token, User.class);
          if (user != null) {
             return ResponseData.ok().putDataValue("user", user);
          }
          return ResponseData.customerError().putDataValue(ResponseData.ERRORS_KEY, new String[] { "token不合法" });
       }
    }

## 接下来用postman调用接口测试一下： ##

![Center 1][]

成功返回：

![Center 2][]

## 这样一个简单完整的jwt就完成了。 ##

项目下载地址：[http://download.csdn.net/download/gaowenhui2008/10047902][http_download.csdn.net_download_gaowenhui2008_10047902]

[Image 1]: 
[Center]: /images/20220606/6a98fa12ab03415896ddd9162dfdd3ce.png
[Center 1]: /images/20220606/89a6a6fc0de947a9a04dd3ef7bb43f2d.png
[Center 2]: /images/20220606/ca1f4229d91248ab869431e1e713ddcf.png
[http_download.csdn.net_download_gaowenhui2008_10047902]: http://download.csdn.net/download/gaowenhui2008/10047902