一、問題背景

公司開發(fā)的系統(tǒng)，有一套自己實現(xiàn)的權(quán)限控制體系。但是在一次安全漏洞檢測中，發(fā)現(xiàn)系統(tǒng)的權(quán)限控制存在漏洞。因為只是在前臺頁面中，利用js和css控制了按鈕是否可以訪問，在登錄時獲取用戶擁有的菜單。
但是用戶可以繞開前臺頁面進行操作。對于菜單，用戶可以通過在地址欄中拼接地址，進行越權(quán)訪問。對于權(quán)限控制的按鈕，用戶可以通過使用postman等接口工具，進行請求的調(diào)用。
因此，系統(tǒng)存在“功能越權(quán)漏洞”。

二、分析問題

這個漏洞的根本原因是，權(quán)限控制僅僅只在前臺進行了控制，在后臺沒有控制。而要在后臺進行控制，肯定是要找個公共的地方進行權(quán)限控制，那就考慮到攔截器和過濾器（此處，補下攔截器和過濾器的知識）。由于只需要對controller請求控制，且之前在攔截器中做過非法路徑，因此選擇在攔截器中進行控制。

三、解決方案

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

核心就是要進行權(quán)限判斷，至于判斷的位置、判斷的內(nèi)容、判斷后的結(jié)果接下來一一進行說明
（1）判斷的位置：攔截器，因為所有的請求都要經(jīng)過攔截器。
（2）判斷的內(nèi)容：判斷請求路徑對應(yīng)的功能是否在用戶的權(quán)限列表中。請求路徑可以從request.getServletPath()獲取，但要對應(yīng)到具體的功能的話，無法直接獲取，需要建立個配置文件來保存映射關(guān)系。用戶的功能列表，可以從數(shù)據(jù)庫查詢，但是考慮到效率，可以在登錄時，將用戶的功能權(quán)限列表保存在memcache中。
（3）判斷的結(jié)果：在攔截器的preHandle方法中返回true或false。
另外，并不是所有的請求都需要進行權(quán)限控制，因此考慮在需要進行權(quán)限控制的contrller方法上加個自定義注解，進行標志。
最后，還有一類項目角色權(quán)限，要跟項目掛鉤。這種需要在請求參數(shù)中傳項目編號。并且在攔截中獲取讀取項目編號。
（問題又來了，由于request請求設(shè)置的content-type為application/json類型，在后臺controller的方法，是用@RequestBody的方式接收參數(shù)。這種方式是調(diào)用request的getInputStream方法讀取數(shù)據(jù)，這種方法只能調(diào)用一次。在攔截器讀了之后，在controller中就讀不到了。具體解決方法，在下面進行說明。）

（二）解決方案的代碼實現(xiàn)：

1.在需要進行權(quán)限校驗的方法前加注解
（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;
/**
 * 自定義權(quán)限注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AuthManager {
    /**
     * 數(shù)據(jù)返回類型 jsp:返回的是jsp 默認 json
     *
     * @return
     */
    String dataType() default "json";

    /**
     * 權(quán)限的類型：菜單權(quán)限、普通按鈕、項目關(guān)聯(lián)按鈕:
     *
     * @return
     */
    String authType() default "";
}

（2）在需要進行權(quán)限校驗的方法前添加該注解

    /**
     * 風(fēng)險審批通過
     */
    @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<Map<String, Object>> result = new ResponseVo<>();
       // 相關(guān)處理
        }
        writeJSON(response, result);
    }

2.將權(quán)限編碼與請求地址進行配置
auth.properties

#投配指令管理
#風(fēng)險審核-通過
investCommand_risk_approvePass=CA400000010_approve

3.重點來了，在攔截器中進行權(quán)限控制
針對與項目相關(guān)的按鈕權(quán)限，需要在攔截器中獲取請求參數(shù)中傳入的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;

    /**
     * 沒有權(quán)限，操作禁止
     */
    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("允許訪問路徑個數(shù)：" + 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;
            }

            // 調(diào)用驗證權(quán)限方法
            String validPermission = this.validPermission(userSession, request, handler);
            // 用戶沒有該權(quán)限時，返回錯誤頁面
            if (Constant.AUTH_VALID_TYPE_NO.equals(validPermission)) {
                System.out.println("用戶沒有該權(quán)限");
                this.doErrorResponse(request, response, OPERATION_FORBIDDEN);
                return false;
            }
        }

        return true;
    }

    private void doErrorResponse(HttpServletRequest request, HttpServletResponse response, String code) throws IOException {
        Map<String, Object> 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);
        }

        // 沒有權(quán)限
        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，否則沒有反應(yīng)
        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();
        }
    }

    // 判斷用戶是否有請求功能的權(quán)限

    /**
     * 驗證用戶是否有權(quán)限
     *
     * @param userSession        用戶session
     * @param HttpServletRequest 注解參數(shù)
     * @param Object             請求
     * @return
     */
    private String validPermission(UserVo userSession, HttpServletRequest request, Object handler) {

        // 初始化為 無權(quán)限
        String validAuthFlag = Constant.AUTH_VALID_TYPE_NO;
        try {
            // 利用注解進行權(quán)限判斷
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            AuthManager auth = handlerMethod.getMethodAnnotation(AuthManager.class);

            // 如果沒有加權(quán)限注解，則不需要進行權(quán)限判斷
            if (auth == null) {
                validAuthFlag = Constant.AUTH_VALID_TYPE_NOT_NEED;
                return validAuthFlag;
            }

            String authIdStr = "";
            String reqAuthUrl = request.getServletPath().substring(6).replace("/", "_");
            // 該請求對應(yīng)的權(quán)限編碼list
            List<String> authList;

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

                // 判斷權(quán)限類型
                if (Constant.AUTH_TYPE_MENU.equals(auth.authType())) {
                    // 菜單類權(quán)限
                    // 判斷功能對應(yīng)authList是否包含在用戶的權(quán)限列表中
                    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())) {
                    // 普通按鈕權(quán)限
                    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())) {
                    // 獲取請求參數(shù)中的項目編號
                    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)) {
                        // 判斷用戶是否有超級權(quán)限
                        if (userSession.getProjectCoInstitutionList() != null && userSession.getProjectCoInstitutionList().size() > 0) {
                            // 如果有,查詢該項目的所屬機構(gòu)
                            ProjectVo projectVo = new ProjectVo();
                            projectVo.setProjectCode(projectCode);
                            TFamilyProject familyProject = projectService.getProject(projectVo);
                            if (familyProject != null && userSession.getProjectCoInstitutionList().contains(familyProject.getCoInstitution())) {
                                // 有該項目所屬機構(gòu)的超級權(quán)限
                                validAuthFlag = Constant.AUTH_VALID_TYPE_YES;
                            }
                        }

                        //  項目按鈕權(quán)限
                        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;
    }

}