spring security中的csrf防御原理(跨域请求伪造)

2023-08-04 17:14:04 74

什么是csrf？

csrf又称跨域请求伪造，攻击方通过伪造用户请求访问受信任站点。CSRF这种攻击方式在2000年已经被国外的安全人员提出，但在国内，直到06年才开始被关注，08年，国内外的多个大型社区和交互网站分别爆出CSRF漏洞，如：NYTimes.com（纽约时报）、Metafilter（一个大型的BLOG网站），YouTube和百度HI......而现在，互联网上的许多站点仍对此毫无防备，以至于安全业界称CSRF为“沉睡的巨人”。

举个例子，用户通过表单发送请求到银行网站，银行网站获取请求参数后对用户账户做出更改。在用户没有退出银行网站情况下，访问了攻击网站，攻击网站中有一段跨域访问的代码，可能自动触发也可能点击提交按钮，访问的url正是银行网站接受表单的url。因为都来自于用户的浏览器端，银行将请求看作是用户发起的，所以对请求进行了处理，造成的结果就是用户的银行账户被攻击网站修改。

解决方法基本上都是增加攻击网站无法获取到的一些表单信息，比如增加图片验证码，可以杜绝csrf攻击，但是除了登陆注册之外，其他的地方都不适合放验证码，因为降低了网站易用性

相关介绍：

http://baike.baidu.com/view/1609487.htm?fr=aladdin

spring-servlet中配置csrf

在类中声明Csrf拦截器，用来生成或去除CsrfToken

importjava.io.IOException;

importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;

importorg.apache.logging.log4j.LogManager;
importorg.apache.logging.log4j.Logger;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.web.method.HandlerMethod;
importorg.springframework.web.servlet.ModelAndView;
importorg.springframework.web.servlet.handler.HandlerInterceptorAdapter;

importcom.wangzhixuan.commons.scan.ExceptionResolver;
importcom.wangzhixuan.commons.utils.WebUtils;

/**
*Csrf拦截器，用来生成或去除CsrfToken
*
*@authorL.cm
*/
publicclassCsrfInterceptorextendsHandlerInterceptorAdapter{
privatestaticfinalLoggerlogger=LogManager.getLogger(ExceptionResolver.class);

@Autowired
privateCsrfTokenRepositorycsrfTokenRepository;

@Override
publicbooleanpreHandle(HttpServletRequestrequest,HttpServletResponseresponse,Objecthandler)throwsException{
HandlerMethodhandlerMethod=(HandlerMethod)handler;
//非控制器请求直接跳出
if(!(handlerinstanceofHandlerMethod)){
returntrue;
}
CsrfTokencsrfToken=handlerMethod.getMethodAnnotation(CsrfToken.class);
//判断是否含有@CsrfToken注解
if(null==csrfToken){
returntrue;
}
//create、remove同时为true时异常
if(csrfToken.create()&&csrfToken.remove()){
logger.error("CsrfTokenattrcreateandremovecanNotatthesametimetotrue!");
returnrenderError(request,response,Boolean.FALSE,"CsrfTokenattrcreateandremovecanNotatthesametimetotrue!");
}
//创建
if(csrfToken.create()){
CsrfTokenBeantoken=csrfTokenRepository.generateToken(request);
csrfTokenRepository.saveToken(token,request,response);
//缓存一个表单页面地址的url
csrfTokenRepository.cacheUrl(request,response);
request.setAttribute(token.getParameterName(),token);
returntrue;
}
//判断是否ajax请求
booleanisAjax=WebUtils.isAjax(handlerMethod);
//校验，并且清除
CsrfTokenBeantokenBean=csrfTokenRepository.loadToken(request);
if(tokenBean==null){
returnrenderError(request,response,isAjax,"CsrfTokenisnull!");
}
StringactualToken=request.getHeader(tokenBean.getHeaderName());
if(actualToken==null){
actualToken=request.getParameter(tokenBean.getParameterName());
}
if(!tokenBean.getToken().equals(actualToken)){
returnrenderError(request,response,isAjax,"CsrfTokennoteq!");
}
returntrue;
}

privatebooleanrenderError(HttpServletRequestrequest,HttpServletResponseresponse,
booleanisAjax,Stringmessage)throwsIOException{
//获取缓存的cacheUrl
StringcachedUrl=csrfTokenRepository.getRemoveCacheUrl(request,response);
//ajax请求直接抛出异常，因为{@linkExceptionResolver}会去处理
if(isAjax){
thrownewRuntimeException(message);
}
//非ajaxCsrfToken校验异常，先清理token
csrfTokenRepository.saveToken(null,request,response);
logger.info("Csrf[redirectUrl]:\t"+cachedUrl);
response.sendRedirect(cachedUrl);
returnfalse;
}

/**
*用于清理@CsrfToken保证只能请求成功一次
*/
@Override
publicvoidpostHandle(HttpServletRequestrequest,HttpServletResponseresponse,Objecthandler,
ModelAndViewmodelAndView)throwsException{
HandlerMethodhandlerMethod=(HandlerMethod)handler;
//非控制器请求直接跳出
if(!(handlerinstanceofHandlerMethod)){
return;
}
CsrfTokencsrfToken=handlerMethod.getMethodAnnotation(CsrfToken.class);
if(csrfToken==null||!csrfToken.remove()){
return;
}
csrfTokenRepository.getRemoveCacheUrl(request,response);
csrfTokenRepository.saveToken(null,request,response);
}

}

声明Csrf过滤注解，通过标注来过滤对应的请求

importjava.lang.annotation.ElementType;
importjava.lang.annotation.Retention;
importjava.lang.annotation.RetentionPolicy;
importjava.lang.annotation.Target;

/**
*Csrf过滤注解
*@authorL.cm
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public@interfaceCsrfToken{
booleancreate()defaultfalse;
booleanremove()defaultfalse;
}

建立实例对象（操作对象）

importjava.io.Serializable;
importorg.springframework.util.Assert;
publicclassCsrfTokenBeanimplementsSerializable{
privatestaticfinallongserialVersionUID=-6865031901744243607L;
privatefinalStringtoken;
privatefinalStringparameterName;
privatefinalStringheaderName;
/**
*Createsanewinstance
*@paramheaderNametheHTTPheadernametouse
*@paramparameterNametheHTTPparameternametouse
*@paramtokenthevalueofthetoken(i.e.expectedvalueoftheHTTPparameterof
*parametername).
*/
publicCsrfTokenBean(StringheaderName,StringparameterName,Stringtoken){
Assert.hasLength(headerName,"headerNamecannotbenullorempty");
Assert.hasLength(parameterName,"parameterNamecannotbenullorempty");
Assert.hasLength(token,"tokencannotbenullorempty");
this.headerName=headerName;
this.parameterName=parameterName;
this.token=token;
}
publicStringgetHeaderName(){
returnthis.headerName;
}
publicStringgetParameterName(){
returnthis.parameterName;
}
publicStringgetToken(){
returnthis.token;
}
}

过滤过程中需要的仓库

packagecom.wangzhixuan.commons.csrf;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
publicinterfaceCsrfTokenRepository{
/**
*Generatesa{@linkCsrfTokenBean}
*
*@paramrequestthe{@linkHttpServletRequest}touse
*@returnthe{@linkCsrfTokenBean}thatwasgenerated.Cannotbenull.
*/
CsrfTokenBeangenerateToken(HttpServletRequestrequest);
/**
*Savesthe{@linkCsrfTokenBean}usingthe{@linkHttpServletRequest}and
*{@linkHttpServletResponse}.Ifthe{@linkCsrfTokenBean}isnull,itisthesameas
*deletingit.
*
*@paramtokenthe{@linkCsrfTokenBean}tosaveornulltodelete
*@paramrequestthe{@linkHttpServletRequest}touse
*@paramresponsethe{@linkHttpServletResponse}touse
*/
voidsaveToken(CsrfTokenBeantoken,HttpServletRequestrequest,
HttpServletResponseresponse);
/**
*Loadstheexpected{@linkCsrfTokenBean}fromthe{@linkHttpServletRequest}
*
*@paramrequestthe{@linkHttpServletRequest}touse
*@returnthe{@linkCsrfTokenBean}ornullifnoneexists
*/
CsrfTokenBeanloadToken(HttpServletRequestrequest);
/**
*缓存来源的url
*@paramrequestrequestthe{@linkHttpServletRequest}touse
*@paramresponsethe{@linkHttpServletResponse}touse
*/
voidcacheUrl(HttpServletRequestrequest,HttpServletResponseresponse);
/**
*获取并清理来源的url
*@paramrequestthe{@linkHttpServletRequest}touse
*@paramresponsethe{@linkHttpServletResponse}touse
*@return来源url
*/
StringgetRemoveCacheUrl(HttpServletRequestrequest,HttpServletResponseresponse);
}

HttpSessionCsrfTokenRepository

packagecom.wangzhixuan.commons.csrf;
importjava.util.UUID;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
importjavax.servlet.http.HttpSession;
importcom.wangzhixuan.commons.utils.StringUtils;
publicfinalclassHttpSessionCsrfTokenRepositoryimplementsCsrfTokenRepository{
privatestaticfinalStringDEFAULT_CSRF_PARAMETER_NAME="_csrf";
privatestaticfinalStringDEFAULT_CSRF_HEADER_NAME="X-CSRF-TOKEN";
privatestaticfinalStringDEFAULT_CSRF_TOKEN_ATTR_NAME=HttpSessionCsrfTokenRepository.class
.getName().concat(".CSRF_TOKEN");
privatestaticfinalStringDEFAULT_CACHE_URL_ATTR_NAME=HttpSessionCsrfTokenRepository.class
.getName().concat(".CACHE_URL");
privateStringparameterName=DEFAULT_CSRF_PARAMETER_NAME;
privateStringheaderName=DEFAULT_CSRF_HEADER_NAME;
privateStringsessionAttributeName=DEFAULT_CSRF_TOKEN_ATTR_NAME;
privateStringcacheUrlAttributeName=DEFAULT_CACHE_URL_ATTR_NAME;
/*
*(non-Javadoc)
*
*@seeorg.springframework.security.web.csrf.CsrfTokenRepository#saveToken(org.
*springframework.security.web.csrf.CsrfToken,
*javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
*/
publicvoidsaveToken(CsrfTokenBeantoken,HttpServletRequestrequest,
HttpServletResponseresponse){
if(token==null){
HttpSessionsession=request.getSession(false);
if(session!=null){
session.removeAttribute(this.sessionAttributeName);
}
}
else{
HttpSessionsession=request.getSession();
session.setAttribute(this.sessionAttributeName,token);
}
}
/*
*(non-Javadoc)
*
*@see
*org.springframework.security.web.csrf.CsrfTokenRepository#loadToken(javax.servlet
*.http.HttpServletRequest)
*/
publicCsrfTokenBeanloadToken(HttpServletRequestrequest){
HttpSessionsession=request.getSession(false);
if(session==null){
returnnull;
}
return(CsrfTokenBean)session.getAttribute(this.sessionAttributeName);
}
/*
*(non-Javadoc)
*
*@seeorg.springframework.security.web.csrf.CsrfTokenRepository#generateToken(javax.
*servlet.http.HttpServletRequest)
*/
publicCsrfTokenBeangenerateToken(HttpServletRequestrequest){
returnnewCsrfTokenBean(this.headerName,this.parameterName,
createNewToken());
}
privateStringcreateNewToken(){
returnUUID.randomUUID().toString();
}
@Override
publicvoidcacheUrl(HttpServletRequestrequest,HttpServletResponseresponse){
StringqueryString=request.getQueryString();
//被拦截前的请求URL
StringredirectUrl=request.getRequestURI();
if(StringUtils.isNotBlank(queryString)){
redirectUrl=redirectUrl.concat("?").concat(queryString);
}
HttpSessionsession=request.getSession();
session.setAttribute(this.cacheUrlAttributeName,redirectUrl);
}
@Override
publicStringgetRemoveCacheUrl(HttpServletRequestrequest,HttpServletResponseresponse){
HttpSessionsession=request.getSession(false);
if(session==null){
returnnull;
}
StringredirectUrl=(String)session.getAttribute(this.cacheUrlAttributeName);
if(StringUtils.isBlank(redirectUrl)){
returnnull;
}
session.removeAttribute(this.cacheUrlAttributeName);
returnredirectUrl;
}
}

总结

以上所述是小编给大家介绍的springsecurity中的csrf防御原理(跨域请求伪造)，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对毛票票网站的支持！
如果你觉得本文对你有帮助，欢迎转载，烦请注明出处，谢谢！

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

spring security中的csrf防御原理(跨域请求伪造)

热门推荐

随机推荐