简介
登录模块很简单,前端发送账号密码的表单,后端接收验证后即可~
淦!可是我想多了,于是有了以下几个问题(里面还包含网络安全问题):
1.登录时的验证码
2.自动登录的实现
3.怎么维护前后端登录状态
在这和大家分享下我实现此功能的过程,包括一些技术和心得
1.登录时的验证码
为什么要验证码,原因很简单,防止脚本无限次重复登录,来暴力破解用户密码或者攻击服务器
验证码的出现,使得每次登录都有个动态变量需要输入,无法用脚本写死代码
具体可以参考:滑动验证码的设计和理解
2.自动登录的实现
所谓自动登录,指的是当用户登录网站时勾选了自动登录,那么下次再访问网站就不需要输入账号密码直接登录了
这说明,账号密码信息是必须保存在用户这边的,因此自动登录都是不安全的!(方便的代价呀)
尽管不安全,但是我们也必须要尽力让它安全一点,有以下常用方法:
1.账号密码加密保存
2.降低自动登录后用户的权限(如果用户自动登录想改密码,想给我转钱等操作的话,就必须输入账号密码再登录一次!)
3.进行ip检测(之前登录的ip小本本记着),如果发现和上次不一致,则不允许自动登录
数据存储在前端哪里呢
浏览器有3个经常保存数据的地方
1.Cookie (我用这个)
2.LocalStorage
3.SessionStorage
各位可以按F12直接观看
如果你在多个大型网站下都按按F12,会发现SessionStorage基本没数据
为啥,因为真的不好用,它并不是后台的session那样,生命周期是一个会话,这个SessionStorage存储的数据只限于该标签的页面
意思是标签1和标签2即使是同个URL的网址,里面的数据都是不互通的(这有个毛用)
那么LocalStorage存储的数据如何呢,答案是无限期本地存储
不过后台无法操作这里的数据,只能由js代码操作(至于操作结果,完全看js,后端无法感知,不太可靠),我认为这里不适合保存敏感点的信息,因为前端的功能是展示,状态性的数据应该由后端直接掌控(后端能直接操作Cookie,保证完成任务)
你看英雄所见略同,CSDN网站的用户密码也是存在Cookie的
Token就是登录后的令牌(下一点会讲)
所以用Cookie就对啦,具体实现都很简单,前端多个自动登录的选择,选择后多个参数传给后端,后端根据参数往Cookie里设置加密后的账号密码
等下次访问时,用拦截器Interceptor进行拦截,检测是否要自动登录即可~
3.如何维护前后端登录状态
大家最先想到是用Session来维护,登录后在Session中存放用户信息,不过对分布式很不友好(什么,你说你用不到分布式,我也没用到,可是梦想还是要有的嘛),需要维护个分布式数据库来进行数据同步才行
于是我用Token实现的,Token就是一串字符串,最适合API鉴权(例如SSO单点登录这种),俗称令牌
好处就是账号密码用户输入一次就够了,特别是多个系统之间(一张身份的凭证都通用)
当用户登录后,服务器就会生成一个Token放在Cookie中,之后用户的所有操作都带这个Token访问(将Token放入http头部)
为什么要将Token放入头部
1.能抵挡下简单的CSRF攻击
2.浏览器跨域问题
什么是CSRF攻击
举个例子:我登录了A网站,A网站给我返回了一些Cookie信息,然后我再同一浏览器的另外标签访问了B网站,谁知这个B网站返回了一些攻击代码(向A网站发起一些请求,比如转钱给你,这时候由于是访问A网站,会附带A网站的Cookie,让一切都好像是我在访问一样),这个就是CSRF攻击
但B网站并不知道A网站这么鸡贼,会在头部放了Token,所以这次攻击请求是的头部是没Token的,因此检测后发现非法,所以没得逞
当然,这并不可靠,哪天B网站知道你头部放了Token,它研究A网站的js代码,清楚逻辑之后也加上,那就防不住了(所以说前端的东西一切都不可靠)
正确做法应该是后端检测头部的Referer字段,每个网页里发起请求,请求的头部都会带有此字段,如
这说明这个请求是从 http://localhost:8099/swr 中发出的
B网站如果返回攻击代码,这里显示的事B网站的网址,判断出不是自家网站发出,就可以禁止访问
浏览器跨域访问会发生什么
说到跨域(自家网站去请求别人家的网站),得先了解什么是同源策略:
同源策略(Same origin policy)是一种约定,它是浏览器最核心也最基本的安全功能,如果缺少了同源策略,则浏览器的正常功能可能都会受到影响。可以说 Web 是构建在同源策略基础之上的,浏览器只是针对同源策略的一种实现。
它的核心就在于它认为自任何站点装载的信赖内容是不安全的。当被浏览器半信半疑的脚本运行在沙箱时,它们应该只被允许访问来自同一站点的资源,而不是那些来自其它站点可能怀有恶意的资源。
所谓同源是指:域名、协议、端口相同。
下表是相对于 http://www.laixiangran.cn/home/index.html
的同源检测结果:
另外,同源策略又分为以下两种:
- DOM 同源策略:禁止对不同源页面 DOM 进行操作。这里主要场景是 iframe 跨域的情况,不同域名的 iframe 是限制互相访问的。
- XMLHttpRequest 同源策略:禁止使用 XHR 对象向不同源的服务器地址发起 HTTP 请求。(就是ajax)
咳咳,这里要说下第二种,其实设置一些参数之后,ajax访问时允许跨域请求的,甚至允许跨域时带上自身cookie
但是,带上自己的Cookie多不安全,明明里面只有1,2个信息要传给对方,现在被人全看见了(不好不好),所以要将Token放入头部
你说为啥不放到参数里,因为这会跟业务用的参数混淆,造成逻辑混乱(就好像你上学时要扔家里的垃圾,你不会放到书包里吧,都是手里提着的)
每个请求都放token,所以要封装起来,例如我是将ajax封装起一个新的对象,然后在这个对象使用时添加Token
当然啦,封装了ajax后还有其他好处(例如统一的成功,失败回调函数,统一的数据解析,统一的等待框等等),有兴趣的同学可以看下
1 /** 2 * 访问后台的对象,为ajax封装 3 * @param url 后台资源路径 4 * @param param Map参数 5 * @param contentType 传输类型 6 * @param success 成功回调函数 7 * @param error 失败回调函数 8 * @param requestType 请求类型(get.post,put,delete) 9 * @constructor 10 */ 11 var Query = function (url,param,contentType,successFunc,errorFunc,requestType) { 12 this.url = url; 13 14 //先确认参数存在 15 if (param) { 16 如果是get请求类型,则将参数拼接到url后面 17 if (requestType == Query.GET_TYPE) { 18 this.param = this._concatParamToURL(param,url); 19 } else { 20 其他请求类型,要根据不同的传输格式来确定传输的值的类型 21 if (contentType == Query.NOMAL_TYPE) { 22 this.param = JSON.parse(._convertParamToJson(param)); 23 } 24 ._convertParamToJson(param); 25 } 26 } 27 } 28 null; 29 } 30 31 32 this.contentType = contentType; 33 this.successFunc = successFunc; 34 this.errorFunc = errorFunc; 35 请求超时,默认10秒 36 this.timeout = 10000 37 是否异步请求,默认异步 38 this.async = true 39 this.requestType = requestType; 40 } 41 42 Query.JSON_TYPE = 'application/json' 43 Query.NOMAL_TYPE = 'application/x-www-form-urlencoded' 44 45 46 * ajax请求的访问 47 * 默认是post 48 * @param url 要访问的地址 49 * @param paramMap 传给后台的Map参数,key为字符串类型 50 * @param callback 回调函数 51 * @param contentType 传输数据的格式 默认传输application/x-www-form-urlencoded格式 52 53 Query.create = 54 return new Query(url,Query.NOMAL_TYPE,Query.GET_TYPE); 55 56 57 -----------------------以下为RESTFul方法--------------------------- 58 ajax请求类型 59 Query.GET_TYPE = "get" 60 Query.POST_TYPE = "post" 61 Query.PUT_TYPE = "put" 62 Query.DELETE_TYPE = "delete" 63 64 get方法默认是Query.NOMAL_TYPE 65 Query.createGetType = 66 67 68 Query.createPostType = 69 70 71 Query.createPutType = 72 73 74 Query.createDeleteType = 75 76 77 78 79 * 将paramMap参数转为json格式 80 * @param paramMap 81 * @private 82 83 Query.prototype._convertParamToJson = (paramMap) { 84 85 return window.tool.strMap2Json(paramMap); 86 87 88 89 90 * 将参数拼接至URL尾部 91 92 * @param url 93 94 95 Query.prototype._concatParamToURL = (paramMap,url) { 96 let size = paramMap.size; 97 98 if (size > 0) { 99 let count = 0100 url = url + "?"101 let urlParam = ""102 103 for (let [k,v] of paramMap) { 104 urlParam = urlParam + encodeURIComponent(k) + "=" + encodeURIComponent(v); 105 if (count < size-1106 urlParam = urlParam + " && "107 count++108 109 110 url = url + urlParam; 111 112 113 114 115 ajax需要跳转的界面 116 Query.REDIRECT_URL = "REDIRECT_URL"117 118 119 * ajax成功返回时调用的方法 120 * 会根据ajax的ContentType类型,转换Response对象的data给回调的成功函数 121 * 如application/json格式类型,data会转成json类型传递 122 * @param queryResult 返回的值,通常为后台的Response对象 123 124 125 Query.prototype._successFunc = (queryResult) { 126 var data = .__afterSuccessComplete(queryResult); 127 if (.successFunc) { 128 .successFunc(data); 129 130 131 如果有需要跳转的页面,则自动跳转 132 if (data && data.REDIRECT_URL != 133 window.location = data.REDIRECT_URL; 134 135 136 137 138 * 会根据ajax的ContentType类型,转换Response对象的data给回调的失败函数 139 140 * 如果对获得的参数不满意,可以用this.getMsg或this.getJsonMsg来进行获取(this指Query对象) 141 * 142 * 这里错误分3种 143 * 1.是Web容器出错 144 * 2.是Filter过滤器主动报错(如一些校验失败后主动抛出,会有错误提示) 145 * 3.是Spring抛出,Spring异常会全局捕捉进行封装 146 147 148 149 Query.prototype._errorFunc = 150 151 返回的信息 152 .__afterErrorComplete(queryResult); 153 如果data里面没东西 154 if (!data) { 155 data = queryResult.statusText; 156 157 158 是否调用者自身已解决了错误 159 var handleError = false160 161 调用回调函数,如果返回结果为true,则不会默认错误处理 162 this.errorFunc instanceof Function) { 163 handleError = .errorFunc(data); 164 165 166 错误编号 167 var code; 168 错误信息 169 msg; 170 171 没有取消对错误的后续处理,那么进行跳转 172 handleError) { 173 174 如果data成功转为Json对象 175 (data) { 176 Filter过滤器主动报错(如一些校验失败后主动抛出,会有错误提示) 177 (data.status) { 178 code = data.status; 179 180 (data.message) { 181 msg = data.message; 182 183 184 185 最终跳转至错误页面 186 var path = "/system/error"187 if (code && msg) { 188 path = path + "/" + error.code + "/" + error.msg; 189 190 window.location.href = path; 191 192 193 194 Query.SUCCESS_TYPE = "SUCCESS_TYPE"195 Query.ERROR_TYPE = "ERROR_TYPE"196 197 * 当一个请求完成时,无论成功或失败,都要调用此函数做一些处理 198 * @param queryResult 服务端返回的数据 199 * @returns {*} 200 201 202 Query.prototype._afterComplete = 203 ._cancleLoadDom(); 204 205 206 207 * 成功的返回处理,会将data部分转为对象 208 * 默认application/json会进行单引号转双引号 209 210 * @param queryResult 211 212 213 214 Query.prototype.__afterSuccessComplete = 215 ._afterComplete(); 216 this.response = queryResult; 217 218 var data = queryResult.data; 219 data必须要有内容,且不是对象才有转换的意义 220 if (data && !(data Object)) { 221 data = .getJsonMsg(); 222 223 data; 224 225 226 227 * 失败的返回处理 228 * 最终会根据ajax的contentType来进行data相应类型转换 229 230 231 232 233 Query.prototype.__afterErrorComplete = 234 235 236 queryResult.responseJSON; 237 238 data = queryResult.responseText; 239 240 241 242 243 244 245 * 取消请求时的等待框 246 247 248 Query.prototype._cancleLoadDom = () { 249 取消加载框 250 .loadDom) { 251 $(this.loadDom).remove("#loadingDiv"); 252 253 254 255 256 * 正式发送ajax 257 258 259 Query.prototype.sendMessage = 260 var self = 261 var xhr = $.ajax( 262 { 263 url: .url,264 type: .requestType,1)">265 contentType: .contentType,1)">266 data: .param,1)">267 ajax发送前调用的方法,初始化等待动画 268 @param XHR XMLHttpRequest对象 269 beforeSend: (XHR) { 270 试图从Cookie中获得token放入http头部 271 var token = window.tool.getCookieMap().get(window.commonStaticValue.TOKEN); 272 (token){ 273 XHR.setRequestHeader(window.commonStaticValue.TOKEN,token); 274 } 275 276 绑定本次请求的queryObj 277 XHR.queryObj = self; 278 if (self.beforeSendFunc 279 self.beforeSendFunc(XHR); 280 281 282 if (self.loadDom HTMLElement) { 283 self.loadDom.innerText = ""284 $(self.loadDom).append("<div id='loadingDiv' class='loading'><img src='/image/loading.gif'/></div>"285 } else jQuery) { 286 self.loadDom.empty(); 287 self.loadDom.append("<div id='loadingDiv' class='loading'><img src='/image/loading.gif'/></div>"288 289 },1)">290 将QueryObj设置为上下文 291 context: self,1)">292 success: ._successFunc,1)">293 error: ._errorFunc,1)">294 complete:(){ 295 console.log("ajax完成"296 297 timeout: .timeout,1)">298 async: .async 299 300 ); 301 302 303 -----------------------------------下面提供了获取后台返回信息方法(帮忙封装了) 304 305 * 获取返回信息Response的Meta头 306 307 Query.prototype.getMeta = 308 .response.meta; 309 310 311 312 * 获得返回值里的data部分 313 314 315 Query.prototype.getMsg = 316 .response.data; 317 318 319 320 * 获得返回值里的data部分,尝试将其转为Json对象 321 322 Query.prototype.getJsonMsg = 323 324 325 先将字符串里的"转为双引号 326 var data = window.tool.replaceAll(data,""","\""327 try{ 328 var jsonData = JSON.parse(data); 329 jsonData; 330 }catch (e) { 331 332 333 334 335 336 ------------------------以下为对Query的参数设置--------------------------- 337 338 * 在ajax发送前设置参数,可以有加载的动画,并且请求完成后会自动取消 339 * @param loadDom 需要显示动画的dom节点 340 * @param beforeSendFunc ajax发送前的自定义函数 341 342 Query.prototype.setBeforeSend = (loadDom,beforeSendFunc) { 343 this.loadDom = loadDom; 344 this.beforeSendFunc = beforeSendFunc; 345 346 347 348 * 设置超时时间 349 * @param timeout 350 351 Query.prototype.setTimeOut = (timeout) { 352 this.timeout = timeout; 353 354 355 Query.prototype.setAsync = (async) { 356 this.async = async; 357 }
预防XSS攻击,Filter知识讲解
网上有些文章说,后端设置HttpOnly,让Cookie无法让js读写,可以防止XSS攻击。
(⊙o⊙)…简直就是乱写,首先要了解下什么是XSS攻击
Xss攻击是什么
举个简单的例子,假设你前端有个地方可以输入,然后保存的数据库的地方
用户A输入了以下东西
<script>alert(123)</>
然后这东西就到了后台,当作一串字符串保存了起来
刚好你网站的html代码里,有个地方是显示用户输入过的东西的(例如评论区),然后上面的东西就被加载到html里面,如
<!DOCTYPE html> html> head> meta charset="utf-8" /> title></p><body>
接下来每个人打开你的网站,都会弹出123的对话框,这就是XSS攻击
怎么预防呢,在后端设置过滤器,对输入进行过滤,先上代码
1 /** 2 * @auther: NiceBin 3 * @description: 系统的拦截器,注册在FilterConfig类中进行 4 * 不能使用@WebFilter,因为Filter要排序 5 * 1.对ServletRequest进行封装 6 * 2.防止CSRF,检查http头的Referer字段 7 * @date: 2020/12/15 15:32 8 9 @Component 10 public class SystemFilter implements Filter { 11 private final Logger logger = LoggerFactory.getLogger(SystemFilter.class12 @Autowired 13 private Environment environment; 14 15 @Override 16 void init(FilterConfig filterConfig) throws ServletException { 17 logger.info("系统拦截器SystemFilter开始加载"18 19 20 21 void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) IOException,ServletException { 22 SystemHttpServletRequestWrapper requestWrapper = SystemHttpServletRequestWrapper((HttpServletRequest) request); 23 24 检测http的Referer字段,不允许跨域访问 25 String hostPath = environment.getProperty("server.host-path"26 String referer = requestWrapper.getHeader("Referer"27 if(!Tool.isNull(referer)){ 28 if(referer.lastIndexOf(hostPath)!=0){ 29 ((HttpServletResponse)response).setStatus(HttpStatus.FORBIDDEN.value()); //设置错误状态码 30 31 32 33 chain.doFilter(requestWrapper,response); 34 35 36 37 void destroy() { 38 39 40 }
乍一看,是不是没发现哪里预防了XSS,其实正在的关键点在22行和33行代码,里面的SystemHttpServletRequestWrapper类才是关键,这个类是包装类,是替换参数里的ServletRequest类的,为的就是重写里面的方法,来达到预防XSS的目的,因为Spring也是根据ServletRequest类来进行前端参数读取的,所以它就是后端获得数据的源头
* @description: 包装的httpServlet,进行以下增强 * 1.将流数据取出保存,方便多次读出 * 2.防止XSS攻击,修改读取数据的方法,过滤敏感字符 * @date: 2020/4/23 19:50 7 8 class SystemHttpServletRequestWrapper extends HttpServletRequestWrapper { 9 final byte[] body; 10 HttpServletRequest request; 11 12 public SystemHttpServletRequestWrapper(HttpServletRequest request) IOException { 13 super(request); 14 打印属性 15 printRequestAll(request); 16 body = HttpHelper.getBodyString(request).getBytes(Charset.forName("UTF-8")); //HttpHelper是我自己写的工具类 17 this.request = request; public BufferedReader getReader() 22 new BufferedReader( InputStreamReader(getInputStream())); 23 24 25 26 public ServletInputStream getInputStream() final ByteArrayInputStream bais = ByteArrayInputStream(body); 28 ServletInputStream() { @Override 30 boolean isFinished() { 31 33 35 isReady() { 36 37 40 setReadListener(ReadListener readListener) { 41 42 43 44 45 int read() 46 bais.read(); 47 48 }; 49 50 51 52 * 可以打印出HttpServletRequest里属性的值 53 * @param request 54 55 printRequestAll(HttpServletRequest request){ 56 Enumeration e = request.getHeaderNames(); 57 while (e.hasMoreElements()) { 58 String name = (String) e.nextElement(); 59 String value = request.getHeader(name); 60 System.out.println(name + " = " + value); 61 62 63 64 以下为XSS预防 65 66 public String getParameter(String name) { 67 String value = request.getParameter(name); 68 StringUtils.isEmpty(value)) { 69 value = StringEscapeUtils.escapeHtml4(value); 70 71 value; 72 73 74 75 String[] getParameterValues(String name) { 76 String[] parameterValues = .getParameterValues(name); 77 if (parameterValues == 78 79 80 for (int i = 0; i < parameterValues.length; i++81 String value = parameterValues[i]; 82 parameterValues[i] =83 84 parameterValues; 85 86 }
HttpHelper工具类:
HttpHelper { 2 * 获取请求中的Body内容 @return 6 7 static String getBodyString(ServletRequest request) { 8 StringBuilder sb = StringBuilder(); 9 InputStream inputStream = 10 BufferedReader reader = 11 12 inputStream = request.getInputStream(); 13 reader = new InputStreamReader(inputStream,Charset.forName("UTF-8"))); 14 String line = ""15 while ((line = reader.readLine()) != 16 sb.append(line); 17 18 } (IOException e) { 19 e.printStackTrace(); 20 } finally21 if (inputStream != 22 inputStream.close(); 24 } e.printStackTrace(); 26 27 if (reader != 29 30 reader.close(); 31 } 35 36 sb.toString(); 38 }
可以看到SystemHttpServletRequestWrapper的64行开始,重写了两个获取参数的方法,在获取参数的时候进行过滤即可~
那64行往上是干啥的咧,这个是将ServletRequest里的数据读出来保存一份,因为ServletRequest里的数据流只能读取一次,很不方便
啥意思呢,就是你在这个Filter里
inputStream = request.getInputStream(); reader =String line = "";
while ((line = reader.readLine()) != null) {
sb.append(line);
}
把数据读完,下个Filter再执行这些代码,就没数据了(从而导致Spring也接收不到数据)
所以要保存起来,让后面的过滤器Filter和拦截器Interceptor快乐的读数据,没有后顾之忧(例如上面提到的验证码设计,如果你想用拦截器拦截,然后进行验证,则势必会读数据),既然封装ServletRequest这么重要,那必须得保证这个Filter第一个加载啊
在Springboot中,Filter的排序用@Order是没用的,必须要用FilterRegistrationBean进行注册才能排序,如:
* @description: 为了排序Filter,如果Filter有顺序要求 * 那么需要在此注册,设置order(值越低优先级越高) * 其他没顺序需要的,可以@WebFilter注册 * 如@WebFilter(filterName = "SecurityFilter",urlPatterns = "/*",asyncSupported = true) * @date: 2020/12/15 15:48 @Configuration FilterConfig { 13 SystemFilter systemFilter; 14 * 注册SystemFilter,顺序为1,任何其他filter不能比他优先 17 @Bean 19 FilterRegistrationBean filterRegist(){ 20 FilterRegistrationBean filterRegistrationBean = FilterRegistrationBean(); 21 filterRegistrationBean.setFilter(systemFilter); 22 filterRegistrationBean.setName("SystemFilter"23 filterRegistrationBean.addUrlPatterns("/*"24 filterRegistrationBean.setAsyncSupported(25 filterRegistrationBean.setOrder(126 filterRegistrationBean; 28 }
当然了,如果你没用Springboot,那web.xml中定义的顺序就是Filter加载的顺序
知识点提问:在我们之后的Filter或者Interceptor中,需要
1 SystemHttpServletRequestWrapper requestWrapper = (SystemHttpServletRequestWrapper) request
这样强制转换才能用吗?
答案是不用的,你可以想想Spring也用了这个东西的,它怎么知道你定义的类叫什么名字,怎么强制转换,那么这设计到Java什么知识呢
没错,就是Java的多态性,我们看以下代码
Father { sayName(){ System.out.println("我是爸爸"); } } class Son Father{ sayName(){ System.out.println("我是儿子" Test { @org.junit.Test void test() Exception { Father father = Son(); otherMethod(father); } otherMethod(Father father){ father.sayName(); } }
输出:我是儿子
答错了的留言,看看有多少小伙子~~ 接下来言归正传
选择JWT生成Token
JWT全称JSON Web Tokens 是一种规范化的 token(别人想的挺多挺全面的了,比你自己想的token要好一点)
一个 JWT token 是一个字符串,它由三部分组成,头部、载荷与签名,中间用 . 分隔,例如:xxxxx.yyyyy.zzzzz
头部(header)
头部通常由两部分组成:令牌的类型(即 JWT)和正在使用的签名算法(如 HMAC SHA256 或 RSA.)。
例如:
{ "alg": "HS256","typ": "JWT" }
然后用 Base64Url 编码得到头部,即 xxxxx。Base64Url编码后,才能在URL中正常传输(因为有人会把Token放在URL里.....)
载荷(Payload)
载荷中放置了 token 的一些基本信息,以帮助接受它的服务器来理解这个 token。同时还可以包含一些自定义的信息,用户信息交换,如:
{ "sub": "1" }
可以将载荷用别的方式加密一遍,这样别人得到了token也看不懂
签名(Signature)
签名时需要用到前面编码过的两个字符串,如果以 HMACSHA256 加密,就如下:
HMACSHA256( base64UrlEncode(header) + "." + base64UrlEncode(payload),secret )
加密后再进行 base64url 编码最后得到的字符串就是 token 的第三部分 zzzzz。
组合便可以得到 token:xxxxx.yyyyy.zzzzz。
签名的作用:保证 JWT 没有被篡改过,原理如下:
HMAC 算法是不可逆算法,类似 MD5 和 hash ,但多一个密钥,密钥(即上面的 secret)由服务端持有,客户端把 token 发给服务端后,服务端可以把其中的头部和载荷再加上事先共享的 secret 再进行一次 HMAC 加密,得到的结果和 token 的第三段进行对比,如果一样则表明数据没有被篡改。
具体Java使用:
<dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.10.2</version> </dependency> <!--jwt一些工具类--> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version> </dependency>
1 ** 2 * @auther: NiceBin 3 * @description: Jwt构造器,创建Token来进行身份记录 4 * jwt由3个部分构成:jwt头,有效载荷(主体,payLoad),签名 5 * @date: 2020/5/7 22:40 6 */ JwtTool { 8 9 以下为JwtTool生成时的主题 10 登录是否还有效 11 static final String SUBJECT_ONLINE_STATE = "online_state" 12 13 以下为载荷固定的Key值 主题 final String SUBJECT = "subject" 16 发布时间 17 final String TIME_ISSUED = "timeIssued" 18 过期时间 19 final String EXPIRATION = "expiration" 20 21 22 * 生成token,参数都是载荷(自定义内容) 23 * 其中Map里为非必要数据,而其他参数为必要参数 24 * subject 主题,token生成干啥用的,用上面的常量作为参数 liveTime 存活时间(秒单位),建议使用TimeUnit方便转换 27 * 如TimeUnit.HOURS.toSeconds(1);将1小时转为秒 = 3600 28 claimMap 自定义荷载,可以为空 30 31 static String createToken(String subject,long liveTime,HashMap<String,String> claimMap) Exception { 32 33 SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256; 34 35 毫秒要转为秒 36 long now = System.currentTimeMillis() / 1000 37 38 byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(EncrypRSA.keyString); 39 // Key signingKey = new SecretKeySpec(apiKeySecretBytes,signatureAlgorithm.getJcaName()); 42 JwtBuilder jwtBuilder = Jwts.builder() 43 加密算法 44 .setHeaderParam("alg","HS256") 45 jwt签名 .signWith(signatureAlgorithm,EncrypRSA.convertSecretKey); //这个Key是我自个的密码,你们自己设个字符串也成,这个得保密 47 48 HashMap<String,String> payLoadMap = new HashMap<>(); payLoadMap.put(SUBJECT,subject); payLoadMap.put(TIME_ISSUED,String.valueOf(now)); 51 设置Token的过期时间 52 if (liveTime >= 0 53 long expiration = now + liveTime; 54 payLoadMap.put(EXPIRATION,String.valueOf(expiration)); 55 } 56 throw new SystemException(SystemStaticValue.TOOL_PARAMETER_EXCEPTION_CODE,"liveTime参数异常" 58 59 StringBuilder payLoad = 60 61 62 63 Collections.isEmpty(claimMap)) { payLoadMap.putAll(claimMap); 65 66 67 拼接主题payLoad,采用 key1,value1,key2,value2的格式 68 for (Map.Entry<String,String> entry : payLoadMap.entrySet()) { 69 payLoad.append(entry.getKey()).append(',').append(entry.getValue()).append(',' 71 72 对payLoad进行加密,这样别人Base64URL解密后也不是明文 73 String encrypPayLoad = EncrypRSA.encrypt(payLoad.toString()); 74 75 jwtBuilder.setPayload(encrypPayLoad); 76 77 会自己生成签名,组装 78 jwtBuilder.compact(); 80 81 82 * 私钥解密token信息 83 84 token 85 @return 存有之前定义的Key,value的Map,解析失败则返回null 86 87 HashMap getMap(String token) { 88 Tool.isNull(token)) { 89 90 String encrypPayLoad = Jwts.parser() .setSigningKey(EncrypRSA.convertSecretKey) .parsePlaintextJws(token).getBody(); 93 94 String payLoad = EncrypRSA.decrypt(encrypPayLoad); 95 96 String[] payLoads = payLoad.split("," 97 HashMap<String,String> map = 98 int i = 0; i < payLoads.length - 1; i=i+2 99 map.put(payLoads[i],payLoads[i + 1]); 100 101 map; 102 } (Exception e) { 103 System.out.println("Token解析失败"104 105 106 } 107 110 111 112 * 判断token是否有效 114 map 已经解析过token的map true 为有效 116 117 boolean isAlive(HashMap<String,1)"> map) { 118 119 Collections.isEmpty(map)) { 120 String tokenString = map.get(EXPIRATION); 121 122 Tool.isNull(tokenString)) { 123 long expiration = Long.valueOf(tokenString) / 1000124 long now = System.currentTimeMillis(); 125 if (expiration > now) { 126 127 } 128 130 131 132 133 134 135 136 token 还未被解析的token 139 140 isAlive(String token) { 141 JwtTool.isAlive(JwtTool.getMap(token)); 143 }
至此,Token的生成和使用就介绍完了,大家有没兴趣了解下重放攻击(淦,我也是在某个博文看到的,又得花时间研究)
Https防止半路被截和重放攻击
前面提到了Token就是身份令牌,可以相当于已登录一样进入系统,那么半路被人截了那就不好了
所以要用Https协议,具体怎么设置大家自行百度吧(直接在tomcat操作的,不需要更改代码,证书也有免费的~)
这里说下Https建立连接的过程,来看看为什么就不会被人截获了
1.服务器先向CA(证书颁布机构)申请一个证书(证书里有自己的ip等等消息),然后在自己服务器设置好
2.浏览器向服务器发送HTTPS请求,服务器将自己的证书发给浏览器
3.浏览器拿到证书后,查看证书是否过期啊,ip是不是跟服务器的一样啊,跟检查身份证跟你长得像不像一样,检查没问题后,跟自己系统里的CA列表比对,看看是谁发的(找不到就报错,说证书不可信),比对成功后从列表里拿出对应的CA公钥解密证书(具体方法跟JWT的很像,浏览器用相同的算法和公钥对证书部分进行加密,看得到的值和证书的签名是否一致),得到服务器的公钥
4.然后生成一个传输私钥,用服务器的公钥加密,发给服务器
5.服务器用服务器的私钥解密,得到了传输秘钥,然后用传输秘钥进行加密要传送的信息发给浏览器
6.浏览器用秘钥解密,然后用传输秘钥进行加密要传送的信息发给服务器(对称加密)
7.重复5,6步骤直到结束
以上哪个步骤黑客得到数据都看不懂
至于为什么能防重放攻击,是因为Https通信自带序列号,如果黑客截取了浏览器的请求,重复发送一遍,那么序列号会一样,会被直接丢弃
至此分享完啦,喜欢的小伙伴给个赞呀~~
参考:https://learnku.com/articles/17883
https://www.cnblogs.com/laixiangran/p/9064769.html
ServletRequest