基於JWT 和 Shiro 作接口權限認證

實現目標

• 用戶登陸後， 能經過令牌(token) 來訪問一些須要登陸才能訪問的接口。

JWT 和 Shiro 是什麼

JWT

JWT(json web Tokens)是一種基於JSON的開放標準((RFC 7519)，跨域身份驗證解決方案。

組成

JSON Web Token由三部分組成，它們之間用圓點(.)鏈接。這三部分分別是：

• Header
• Payload
• Signature

Header

header典型的由兩部分組成：token的類型（「JWT」）和算法名稱（好比：HMAC SHA256或者RSA等等）。

例如：

{
  "typ": "JWT",
  "alg": "HS256"
}
複製代碼

而後，用Base64對這個JSON編碼就獲得JWT的第一部分eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9

Payload

Payload 裏面是 Token 的具體內容，這些內容裏面有一些是標準字段，你也能夠添加其它須要的內容。下面是標準字段：

• iss：Issuer，發行者
• sub：Subject，主題
• aud：Audience，觀衆
• exp：Expiration time，過時時間
• nbf：Not before
• iat：Issued at，發行時間
• jti：JWT ID 好比下面這個 Payload ，用到了 iss 發行人，還有 exp 過時時間。另外還有兩個自定義的字段，一個是 name ，還有一個是 admin 。

{
 "iss": "ninghao.net",
 "exp": "1438955445",
 "name": "wanghao",
 "admin": true
}
複製代碼

使用Base64對這個JSON編碼就獲得JWT的第二部分

eyJpc3MiOiJuaW5naGFvLm5ldCIsImV4cCI6IjE0Mzg5NTU0NDUiLCJuYW1lIjoid2FuZ2hhbyIsImFkbWluIjp0cnVlfQ Signature

Signature

JWT 的最後一部分是 Signature ，這部份內容有三個部分，先是用 Base64 編碼 header.payload ，再用加密算法加密一下，加密的時候要放進去一個 Secret ，這個至關因而一個密碼，這個密碼祕密地存儲在服務端，加密過程以下:

String encodedString = base64UrlEncode(header) + "." + base64UrlEncode(payload);

String token = HMACSHA256(encodedString, 'secret');

這時候就獲得了token的第三部分：

SwyHTEx_RQppr97g4J5lKXtabJecpejuef8AqKYMAJc

最後將這三個部分用.拼接起來就是咱們的要發送給客戶端的 Token：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJuaW5naGFvLm5ldCIsImV4cCI6IjE0Mzg5NTU0NDUiLCJuYW1lIjoid2FuZ2hhbyIsImFkbWluIjp0cnVlfQ.SwyHTEx_RQppr97g4J5lKXtabJecpejuef8AqKYMAJc

Shiro

Shiro是一個安全框架， 主要用來作認證和受權，在這裏咱們用到的是受權，對URL進行攔截判斷用戶是否有權限訪問。

總體實現思路

服務端經過JWT來生成token，發送給客戶端。客戶端接收到後，每次請求都把token放在請求頭中，Shiro對沒個接口進行攔截，攔截後取出請求頭中的token給JWT驗證，驗證經過則放行，不經過則報錯無權限錯誤給客戶端。

代碼實現

建立一個spring boot 項目，pom.xml文件以下:

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.domain</groupId>
    <artifactId>hello-jwt-shiro</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>hello-jwt-shiro</name>
    <description>Demo project for Spring Boot with JWT and Shrio</description>


    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <shiro.spring.version>1.4.0</shiro.spring.version>
        <jwt.auth0.version>3.2.0</jwt.auth0.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 使用redis作數據緩存，若是不須要可不依賴 -->
        <!--<dependency>-->
            <!--<groupId>org.springframework.boot</groupId>-->
            <!--<artifactId>spring-boot-starter-data-redis</artifactId>-->
        <!--</dependency>-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-web-starter</artifactId>
            <version>${shiro.spring.version}</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>${jwt.auth0.version}</version>
        </dependency>
        <!--<dependency>-->
            <!--<groupId>org.apache.httpcomponents</groupId>-->
            <!--<artifactId>httpclient</artifactId>-->
            <!--<version>4.5.5</version>-->
        <!--</dependency>-->
        <!--<dependency>-->
            <!--<groupId>org.apache.commons</groupId>-->
            <!--<artifactId>commons-lang3</artifactId>-->
            <!--<version>3.7</version>-->
        <!--</dependency>-->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

複製代碼

Shiro配置文件

設置Token過濾器，以及要過濾的url。 全部須要的過濾的url，都會先通過過濾器，過濾器校驗經過，纔會到controller。

@Configuration
public class ShiroConfiguration {

    @Bean("securityManager")
    public DefaultWebSecurityManager getManager(MyRealm realm) {
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        // 使用本身的realm
        manager.setRealm(realm);

        /*
         * 關閉shiro自帶的session，詳情見文檔
         * http://shiro.apache.org/session-management.html#SessionManagement-StatelessApplications%28Sessionless%29
         */
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        manager.setSubjectDAO(subjectDAO);

        return manager;
    }

    @Bean("shiroFilterFactoryBean")
    public ShiroFilterFactoryBean factory(DefaultWebSecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();

        // 添加本身的過濾器而且取名爲jwt
        Map<String, Filter> filterMap = new HashMap<>();
        filterMap.put("token", new TokenAccessFilter());
        factoryBean.setFilters(filterMap);

        factoryBean.setSecurityManager(securityManager);
        factoryBean.setUnauthorizedUrl("/401");

        /*
         * 自定義url規則
         * http://shiro.apache.org/web.html#urls-
         */
        Map<String, String> filterRuleMap = new HashMap<>();
        // 全部請求經過咱們本身的JWT Filter
        filterRuleMap.put("/login", "anon");
        filterRuleMap.put("/**", "token");
        // 訪問401和404頁面不經過咱們的Filter
        filterRuleMap.put("/401", "anon");
        factoryBean.setFilterChainDefinitionMap(filterRuleMap);
        return factoryBean;
    }

    /**
     * 下面的代碼是添加註解支持
     */
    @Bean
    @DependsOn("lifecycleBeanPostProcessor")
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        // 強制使用cglib，防止重複代理和可能引發代理出錯的問題
        // https://zhuanlan.zhihu.com/p/29161098
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }

    @Bean
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }
}

複製代碼

過濾器實現

獲取客戶端請求頭中的token，交給JWT校驗比對，若是經過就放行,放行後會執行controller代碼，不經過就返回 還沒有登陸。

public class TokenAccessFilter extends AccessControlFilter {

    @Override
    protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object o) throws Exception {
        if(((HttpServletRequest) servletRequest).getMethod().equalsIgnoreCase("OPTIONS")) {
            return true;
        }
        return false;
    }


    @Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws BusinessException, IOException {
        String token = ((HttpServletRequest) servletRequest).getHeader("token");
        if (token==null || token.length()==0) {
            responseError(servletResponse,401,"還沒有登陸");
            return false;
        }
        String username = JWTUtil.getUsername(token);

        if (!JWTUtil.verify(token,username)) {
            responseError(servletResponse,401,"token 驗證失敗");
            return  false;
        }

        return true;
    }

    private void responseError(ServletResponse response,int code,String errorMsg) throws  IOException {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-Control-Allow-Origin","*");
        httpServletResponse.setHeader("Access-Control-Allow-Credentials", "true");
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "*");		httpServletResponse.setHeader("Access-Control-Allow-Headers", "*");
        httpServletResponse.setContentType("application/json; charset=UTF-8");
        ResponseBean baseResponse = new ResponseBean(code,errorMsg,null);
        OutputStream os = httpServletResponse.getOutputStream();
        os.write(new ObjectMapper().writeValueAsString(baseResponse).getBytes("UTF-8"));
        os.flush();
        os.close();
    }
}
複製代碼

token的生成和驗證

public class JWTUtil {

    // 過時時間5分鐘
    private static final long EXPIRE_TIME = 5*60*1000;

    private static final String SECRET = "XX#$%()(#*!()!KL<><MQLMNQNQJQK sdfkjsdrow32234545fdf>?N<:{LWPW";

    /**
     * 校驗token是否正確
     * @param token 密鑰
     * @param secret 用戶的密碼
     * @return 是否正確
     */
    public static boolean verify(String token, String username) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(SECRET);
            JWTVerifier verifier = JWT.require(algorithm)
                    .withClaim("username", username)
                    .build();
            DecodedJWT jwt = verifier.verify(token);
            return true;
        } catch (Exception exception) {
            return false;
        }
    }

    /**
     * 得到token中的信息無需secret解密也能得到
     * @return token中包含的用戶名
     */
    public static String getUsername(String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("username").asString();
        } catch (JWTDecodeException e) {
            return null;
        }
    }

    /**
     * 生成簽名,5min後過時
     * @param username 用戶名
     * @param secret 用戶的密碼
     * @return 加密的token
     */
    public static String sign(String username) {
        try {
            Date date = new Date(System.currentTimeMillis()+EXPIRE_TIME);
            Algorithm algorithm = Algorithm.HMAC256(SECRET);
            // 附帶username信息
            return JWT.create()
                    .withClaim("username", username)
                    .withExpiresAt(date)
                    .sign(algorithm);
        } catch (UnsupportedEncodingException e) {
            return null;
        }
    }
}
複製代碼

自定義Realm

自定義的權限認證和身份認證邏輯。

doGetAuthorizationInfo 方法是權限認證。 doGetAuthenticationInfo 方法是身份認證

getSubject(request, response).login(token) 時就是交給這個自定義類處理。

@Service
public class MyRealm extends AuthorizingRealm {

    private static final Logger LOGGER = LogManager.getLogger(MyRealm.class);

    private UserService userService;

    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

//    /**
//     * 大坑！，必須重寫此方法，否則Shiro會報錯
//     */
//    @Override
//    public boolean supports(AuthenticationToken token) {
//        return token instanceof JWTToken;
//    }

//    /**
//     * 只有當須要檢測用戶權限的時候纔會調用此方法，例如checkRole,checkPermission之類的
//     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String username = JWTUtil.getUsername(principals.toString());
        UserBean user = userService.getUser(username);
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        simpleAuthorizationInfo.addRole(user.getRole());
        Set<String> permission = new HashSet<>(Arrays.asList(user.getPermission().split(",")));
        simpleAuthorizationInfo.addStringPermissions(permission);
        return simpleAuthorizationInfo;
    }

    /**
     * 默認使用此方法進行用戶名正確與否驗證，錯誤拋出異常便可。
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
        String token = (String) auth.getCredentials();
        // 解密得到username，用於和數據庫進行對比
        String username = JWTUtil.getUsername(token);
        if (username == null) {
            throw new AuthenticationException("token invalid");
        }

        UserBean userBean = userService.getUser(username);
        if (userBean == null) {
            throw new AuthenticationException("User didn't existed!");
        }

        if (! JWTUtil.verify(token, username)) {
            throw new AuthenticationException("Username or password error");
        }

        return new SimpleAuthenticationInfo(token, token, "my_realm");
    }
}
複製代碼

項目完整代碼

github.com/domain9065/…