基于SpringMVC的拦截器和自定义注解实现后台权限验证

一、问题背景

公司开发的系统，有一套自己实现的权限控制体系。但是在一次安全漏洞检测中，发现系统的权限控制存在漏洞。因为只是在前台页面中，利用js和css控制了按钮是否可以访问，在登录时获取用户拥有的菜单。
但是用户可以绕开前台页面进行操作。对于菜单，用户可以通过在地址栏中拼接地址，进行越权访问。对于权限控制的按钮，用户可以通过使用postman等接口工具，进行请求的调用。
因此，系统存在“功能越权漏洞”。

二、分析问题

这个漏洞的根本原因是，权限控制仅仅只在前台进行了控制，在后台没有控制。而要在后台进行控制，肯定是要找个公共的地方进行权限控制，那就考虑到拦截器和过滤器（此处，补下拦截器和过滤器的知识）。由于只需要对controller请求控制，且之前在拦截器中做过非法路径，因此选择在拦截器中进行控制。

三、解决方案

（一）解决方案的大致思路：

核心就是要进行权限判断，至于判断的位置、判断的内容、判断后的结果接下来一一进行说明
（1）判断的位置：拦截器，因为所有的请求都要经过拦截器。
（2）判断的内容：判断请求路径对应的功能是否在用户的权限列表中。请求路径可以从request.getServletPath()获取，但要对应到具体的功能的话，无法直接获取，需要建立个配置文件来保存映射关系。用户的功能列表，可以从数据库查询，但是考虑到效率，可以在登录时，将用户的功能权限列表保存在memcache中。
（3）判断的结果：在拦截器的preHandle方法中返回true或false。
另外，并不是所有的请求都需要进行权限控制，因此考虑在需要进行权限控制的contrller方法上加个自定义注解，进行标志。
最后，还有一类项目角色权限，要跟项目挂钩。这种需要在请求参数中传项目编号。并且在拦截中获取读取项目编号。
（问题又来了，由于request请求设置的content-type为application/json类型，在后台controller的方法，是用@RequestBody的方式接收参数。这种方式是调用request的getInputStream方法读取数据，这种方法只能调用一次。在拦截器读了之后，在controller中就读不到了。具体解决方法，在下面进行说明。）

（二）解决方案的代码实现：

1.在需要进行权限校验的方法前加注解
（1）Spring的自定义注解

package cn.caitc.family.web.interceptor;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 自定义权限注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AuthManager {
    /**
     * 数据返回类型 jsp:返回的是jsp 默认 json
     *
     * @return
     */
    String dataType() default "json";

    /**
     * 权限的类型：菜单权限、普通按钮、项目关联按钮:
     *
     * @return
     */
    String authType() default "";
}

（2）在需要进行权限校验的方法前添加该注解

    /**
     * 风险审批通过
     */
    @AuthManager(authType = Constant.AUTH_TYPE_PRO_BUTTON)
    @RequestMapping(value = "/investCommand/risk/approvePass", method = {RequestMethod.POST})
    public void riskApprovePass(HttpServletRequest request, HttpServletResponse response, @RequestBody String jsonStr)
            throws Exception {
        ResponseVo> result = new ResponseVo<>();
       // 相关处理
        }
        writeJSON(response, result);
    }

2.将权限编码与请求地址进行配置
auth.properties

#投配指令管理
#风险审核-通过
investCommand_risk_approvePass=CA400000010_approve

3.重点来了，在拦截器中进行权限控制
针对与项目相关的按钮权限，需要在拦截器中获取请求参数中传入的projectCode.
具体的获取处理办法，后面再写文章说明。

package cn.caitc.family.web.interceptor;

import cn.caitc.common.util.JsonMapper;
import cn.caitc.common.util.PropertiesLoader;
import cn.caitc.family.constant.Constant;
import cn.caitc.family.domain.TFamilyProject;
import cn.caitc.family.service.index.IndexService;
import cn.caitc.family.service.trustProject.ProjectService;
import cn.caitc.family.util.SessionUtil;
import cn.caitc.family.vo.trustProject.ProjectVo;
import cn.caitc.family.vo.userManage.UserVo;
import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.annotation.JsonInclude;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by llj on 2017/2/21.
 */
public class FamilyUrlInterceptor extends HandlerInterceptorAdapter {

    public String[] allowUrls;
    static final Logger logger = LoggerFactory.getLogger(FamilyUrlInterceptor.class);

    @Resource
    private ProjectService projectService;

    public void setAllowUrls(String[] allowUrls) {
        this.allowUrls = allowUrls;
    }

    public static final String NO_FOUND_SESSION = "908";

    private IndexService indexService;

    /**
     * 没有权限，操作禁止
     */
    public static final String OPERATION_FORBIDDEN = "907";

    public FamilyUrlInterceptor() {
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String reqUrl = request.getServletPath();
        // logger.info("请求访问路径：" + reqUrl);

        if (StringUtils.isNotBlank(reqUrl)) {
            reqUrl = reqUrl.replace("/", ".");
            reqUrl = reqUrl.replace("\\", ".");
            if (".".equals(reqUrl.substring(0, 1))) {
                reqUrl = reqUrl.substring(1);
            }

            if (null != allowUrls && allowUrls.length >= 1) {
                for (String url : allowUrls) {
                    if (reqUrl.contains(url)) {
                        //   logger.info("存在于可访问列表" + reqUrl);
                        return true;
                    } else {
                        //    logger.error("非法路径：" + reqUrl);
                    }
                    //  logger.info("允许访问路径：" + url);
                }
                //   logger.info("允许访问路径个数：" + allowUrls.length);
            } else {
                //  logger.error("可访问列表为空" );
            }

            if (request instanceof DefaultMultipartHttpServletRequest) {
                return true;
            }

            UserVo userSession = SessionUtil.getFamilyUserSession(request);
            if (userSession == null) {
                // 如果session失效，则记录用户退出时间
                indexService = (IndexService) WebApplicationContextUtils.getRequiredWebApplicationContext(request.getSession().getServletContext()).getBean("famiIndexService");
                indexService.userLogout(request.getHeader("sessionId"));
                this.doErrorResponse(request, response, NO_FOUND_SESSION);
                return false;
            }

            // 调用验证权限方法
            String validPermission = this.validPermission(userSession, request, handler);
            // 用户没有该权限时，返回错误页面
            if (Constant.AUTH_VALID_TYPE_NO.equals(validPermission)) {
                System.out.println("用户没有该权限");
                this.doErrorResponse(request, response, OPERATION_FORBIDDEN);
                return false;
            }
        }

        return true;
    }

    private void doErrorResponse(HttpServletRequest request, HttpServletResponse response, String code) throws IOException {
        Map result;
        result = new HashMap<>();
        // 没有session时，提示登录
        if (NO_FOUND_SESSION.equals(code)) {
            response.setStatus(Integer.parseInt(NO_FOUND_SESSION));
            result.put("success", false);
            result.put("message", PropertiesLoader.get("E00000001"));
            result.put("msgcode", NO_FOUND_SESSION);
            this.writeJSON(response, result);
        }

        // 没有权限
        if (OPERATION_FORBIDDEN.equals(code)) {
            response.setStatus(Integer.parseInt(OPERATION_FORBIDDEN));
            result.put("success", false);
            result.put("message", PropertiesLoader.get("E00000022"));
            result.put("msgcode", OPERATION_FORBIDDEN);
            writeJSON(response, result);
        }
    }

    protected void writeJSON(HttpServletResponse response, Object obj) {
        // 重置response，否则没有反应
        response.reset();
        response.setContentType("application/json;charset=utf-8");
        try {
            if (obj == null) {
                response.getWriter().print("");
            } else {
                response.getWriter().print((new JsonMapper(JsonInclude.Include.NON_NULL)).toJson(obj));
            }
        } catch (IOException var4) {
            var4.printStackTrace();
        }
    }

    // 判断用户是否有请求功能的权限

    /**
     * 验证用户是否有权限
     *
     * @param userSession        用户session
     * @param HttpServletRequest 注解参数
     * @param Object             请求
     * @return
     */
    private String validPermission(UserVo userSession, HttpServletRequest request, Object handler) {

        // 初始化为 无权限
        String validAuthFlag = Constant.AUTH_VALID_TYPE_NO;
        try {
            // 利用注解进行权限判断
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            AuthManager auth = handlerMethod.getMethodAnnotation(AuthManager.class);

            // 如果没有加权限注解，则不需要进行权限判断
            if (auth == null) {
                validAuthFlag = Constant.AUTH_VALID_TYPE_NOT_NEED;
                return validAuthFlag;
            }

            String authIdStr = "";
            String reqAuthUrl = request.getServletPath().substring(6).replace("/", "_");
            // 该请求对应的权限编码list
            List authList;

            if (auth != null && StringUtils.isNotBlank(auth.authType())) {
                authIdStr = PropertiesLoader.get(reqAuthUrl);
                authList = Arrays.asList(authIdStr.split(","));

                // 判断权限类型
                if (Constant.AUTH_TYPE_MENU.equals(auth.authType())) {
                    // 菜单类权限
                    // 判断功能对应authList是否包含在用户的权限列表中
                    if (userSession.getMkCodeList() != null) {
                        for (String authId : authList) {
                            if (userSession.getMkCodeList().contains(authId)) {
                                validAuthFlag = Constant.AUTH_VALID_TYPE_YES;
                                break;
                            }
                        }
                    }
                } else if (Constant.AUTH_TYPE_BUTTON.equals(auth.authType())) {
                    // 普通按钮权限
                    if (userSession.getSysButtonList() != null) {
                        for (String authId : authList) {
                            if (userSession.getSysButtonList().contains(authId)) {
                                validAuthFlag = Constant.AUTH_VALID_TYPE_YES;
                                break;
                            }
                        }
                    }
                } else if (Constant.AUTH_TYPE_PRO_BUTTON.equals(auth.authType())) {
                    // 获取请求参数中的项目编号
                    FamiHttpServletRequestWrapper myFamiHttpServletRequestWrapper = new FamiHttpServletRequestWrapper((HttpServletRequest) request);
                    String body = myFamiHttpServletRequestWrapper.getBody();
                    Map bodyMap = JSON.parseObject(body);
                    String projectCode = bodyMap.get("projectCode").toString();
                    if (StringUtils.isNotBlank(projectCode)) {
                        // 判断用户是否有超级权限
                        if (userSession.getProjectCoInstitutionList() != null && userSession.getProjectCoInstitutionList().size() > 0) {
                            // 如果有,查询该项目的所属机构
                            ProjectVo projectVo = new ProjectVo();
                            projectVo.setProjectCode(projectCode);
                            TFamilyProject familyProject = projectService.getProject(projectVo);
                            if (familyProject != null && userSession.getProjectCoInstitutionList().contains(familyProject.getCoInstitution())) {
                                // 有该项目所属机构的超级权限
                                validAuthFlag = Constant.AUTH_VALID_TYPE_YES;
                            }
                        }

                        //  项目按钮权限
                        if (userSession.getProButtonList() != null) {
                            for (String authId : authList) {
                                if (userSession.getProButtonList().contains(authId + "|" + projectCode)) {
                                    validAuthFlag = Constant.AUTH_VALID_TYPE_YES;
                                    break;
                                }
                            }
                        }
                    }

                }

            }
        } catch (Exception e) {
            e.printStackTrace();
            return validAuthFlag;
        }
        return validAuthFlag;
    }

}