欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

SpringBoot 防止接口恶意多次请求的操作

程序员文章站 2022-11-17 12:58:48
前言刚写代码不就,还不能做深层次安全措施,今天研究了一下基本的防止接口多次恶意请求的方法。思路1:设置同一ip,一个时间段内允许访问的最大次数2:记录所有ip单位时间内访问的次数3:将所有被限制ip存...

前言

刚写代码不就,还不能做深层次安全措施,今天研究了一下基本的防止接口多次恶意请求的方法。

思路

1:设置同一ip,一个时间段内允许访问的最大次数

2:记录所有ip单位时间内访问的次数

3:将所有被限制ip存到存储器

4:通过ip过滤访问请求

该demo只有后台java代码,没有前端

代码

首先是获取ip的工具类

public class ipsettings { 
 public static string getremotehost(httpservletrequest request) {
  string ipaddress = null;
  //ipaddress = request.getremoteaddr(); 
  ipaddress = request.getheader("x-forwarded-for");
  if(ipaddress == null || ipaddress.length() == 0 || "unknown".equalsignorecase(ipaddress)) {
   ipaddress = request.getheader("proxy-client-ip");
  }
  if(ipaddress == null || ipaddress.length() == 0 || "unknown".equalsignorecase(ipaddress)) {
   ipaddress = request.getheader("wl-proxy-client-ip");
  }
  if(ipaddress == null || ipaddress.length() == 0 || "unknown".equalsignorecase(ipaddress)) {
   ipaddress = request.getremoteaddr();
   if(ipaddress.equals("127.0.0.1")){
    //根据网卡取本机配置的ip 
    inetaddress inet=null;
    try {
     inet = inetaddress.getlocalhost();
    } catch (unknownhostexception e) {
     e.printstacktrace();
    }
    ipaddress= inet.gethostaddress();
   } 
  }
 
  //对于通过多个代理的情况,第一个ip为客户端真实ip,多个ip按照','分割 
  if(ipaddress!=null && ipaddress.length()>15){ //"***.***.***.***".length() = 15 
   if(ipaddress.indexof(",")>0){
    ipaddress = ipaddress.substring(0,ipaddress.indexof(","));
   }
  }
  return ipaddress; 
 }
}

其次是监听器以及ip存储器

import java.util.hashmap;
import java.util.map; 
import javax.servlet.servletcontext;
import javax.servlet.servletcontextevent;
import javax.servlet.servletcontextlistener;
import javax.servlet.annotation.weblistener; 
import org.slf4j.logger;
import org.slf4j.loggerfactory;
@weblistener
public class myapplicationlistener implements servletcontextlistener {
 private logger logger = loggerfactory.getlogger(myapplicationlistener.class);
 @override
 public void contextinitialized(servletcontextevent sce) {
  logger.info("liting: contextinitialized");
  system.err.println("初始化成功");
  servletcontext context = sce.getservletcontext();
  // ip存储器
  map<string, long[]> ipmap = new hashmap<string, long[]>();
  context.setattribute("ipmap", ipmap);
  // 限制ip存储器:存储被限制的ip信息
  map<string, long> limitedipmap = new hashmap<string, long>();
  context.setattribute("limitedipmap", limitedipmap);
  logger.info("ipmap:"+ipmap.tostring()+";limitedipmap:"+limitedipmap.tostring()+"初始化成功。。。。。");
 }
 
 @override
 public void contextdestroyed(servletcontextevent sce) {
  // todo auto-generated method stub
 }
}

最后是具体规则设置

import java.io.ioexception;
import java.util.iterator;
import java.util.map;
import java.util.set; 
import javax.servlet.filter;
import javax.servlet.filterchain;
import javax.servlet.filterconfig;
import javax.servlet.servletcontext;
import javax.servlet.servletexception;
import javax.servlet.servletrequest;
import javax.servlet.servletresponse;
import javax.servlet.annotation.webfilter;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
 
@webfilter(urlpatterns="/*")
public class ipfilter implements filter{
 
 /**
  * 默认限制时间(单位:ms)
  */
 private static final long limited_time_millis = 5 * 2 * 1000;
 
 /**
  * 用户连续访问最高阀值,超过该值则认定为恶意操作的ip,进行限制
  */
 private static final int limit_number = 2;
 
 /**
  * 用户访问最小安全时间,在该时间内如果访问次数大于阀值,则记录为恶意ip,否则视为正常访问
  */
 private static final int min_safe_time = 5000;
 private filterconfig config;
 
 @override
 public void init(filterconfig filterconfig) throws servletexception {
  this.config = filterconfig; //设置属性filterconfig
 }
 
 /* (non-javadoc)
  * @see javax.servlet.filter#dofilter(javax.servlet.servletrequest, javax.servlet.servletresponse, javax.servlet.filterchain)
  */
 @suppresswarnings("unchecked")
 @override
 public void dofilter(servletrequest servletrequest, servletresponse servletresponse, filterchain chain)
   throws ioexception, servletexception {
  httpservletrequest request = (httpservletrequest) servletrequest;
  httpservletresponse response = (httpservletresponse) servletresponse;
  servletcontext context = config.getservletcontext();
  // 获取限制ip存储器:存储被限制的ip信息
  map<string, long> limitedipmap = (map<string, long>) context.getattribute("limitedipmap");
  // 过滤受限的ip
  filterlimitedipmap(limitedipmap);
  // 获取用户ip
  string ip = ipsettings.getremotehost(request);
  system.err.println("ip:"+ip);
  //以下是处理限制ip的规则,可以自己写
  // 判断是否是被限制的ip,如果是则跳到异常页面
  if (islimitedip(limitedipmap, ip)) {
   long limitedtime = limitedipmap.get(ip) - system.currenttimemillis();
   // 剩余限制时间(用为从毫秒到秒转化的一定会存在些许误差,但基本可以忽略不计)
   request.setattribute("remainingtime", ((limitedtime / 1000) + (limitedtime % 1000 > 0 ? 1 : 0)));
   //request.getrequestdispatcher("/error/overlimitip").forward(request, response);
   system.err.println("ip访问过于频繁:"+ip);
   
   return;
  }
  // 获取ip存储器
  map<string, long[]> ipmap = (map<string, long[]>) context.getattribute("ipmap");
  // 判断存储器中是否存在当前ip,如果没有则为初次访问,初始化该ip
  // 如果存在当前ip,则验证当前ip的访问次数
  // 如果大于限制阀值,判断达到阀值的时间,如果不大于[用户访问最小安全时间]则视为恶意访问,跳转到异常页面
  if (ipmap.containskey(ip)) {
   long[] ipinfo = ipmap.get(ip);
   ipinfo[0] = ipinfo[0] + 1;
   system.out.println("当前第[" + (ipinfo[0]) + "]次访问");
   if (ipinfo[0] > limit_number) {
    long ipaccesstime = ipinfo[1];
    long currenttimemillis = system.currenttimemillis();
    if (currenttimemillis - ipaccesstime <= min_safe_time) {
     limitedipmap.put(ip, currenttimemillis + limited_time_millis);
     request.setattribute("remainingtime", limited_time_millis);
     system.err.println("ip访问过于频繁:"+ip);
     request.getrequestdispatcher("/error/overlimitip").forward(request, response);
     return;
    } else {
     initipvisitsnumber(ipmap, ip);
    }
   }
  } else {
   initipvisitsnumber(ipmap, ip);
   system.out.println("您首次访问该网站");
  }
  context.setattribute("ipmap", ipmap);
  chain.dofilter(request, response);
 }
 
 @override
 public void destroy() {
  // todo auto-generated method stub
 }
 
 /**
  * @description 过滤受限的ip,剔除已经到期的限制ip
  * @param limitedipmap
  */
 private void filterlimitedipmap(map<string, long> limitedipmap) {
  if (limitedipmap == null) {
   return;
  }
  set<string> keys = limitedipmap.keyset();
  iterator<string> keyit = keys.iterator();
  long currenttimemillis = system.currenttimemillis();
  while (keyit.hasnext()) {
   long expiretimemillis = limitedipmap.get(keyit.next());
   if (expiretimemillis <= currenttimemillis) {
    keyit.remove();
   }
  }
 }
 
 /**
  * @description 是否是被限制的ip
  * @param limitedipmap
  * @param ip
  * @return true : 被限制 | false : 正常
  */
 private boolean islimitedip(map<string, long> limitedipmap, string ip) {
  if (limitedipmap == null || ip == null) {
   // 没有被限制
   return false;
  }
  set<string> keys = limitedipmap.keyset();
  iterator<string> keyit = keys.iterator();
  while (keyit.hasnext()) {
   string key = keyit.next();
   if (key.equals(ip)) {
    // 被限制的ip
    return true;
   }
  }
  return false;
 }
 
 /**
  * 初始化用户访问次数和访问时间
  *
  * @param ipmap
  * @param ip
  */
 private void initipvisitsnumber(map<string, long[]> ipmap, string ip) {
  long[] ipinfo = new long[2];
  ipinfo[0] = 0l;// 访问次数
  ipinfo[1] = system.currenttimemillis();// 初次访问时间
  ipmap.put(ip, ipinfo);
 }
}

然后再在启动类上加上注解扫描配置包

@servletcomponentscan(basepackages="扫描刚才的myapplicationlistener")

补充:springboot和redis控制单位时间内同个ip访问同个接口的次数

注:本文中的修改于网上一个错误的例子,不知道为什么一个错误的例子还被人疯狂转载,还都标着原创。。。具体是那个这里就不指出了!

第一步:自定义一个注解

注:其实完全没必要(这样做的唯一好处就是每个接口与的访问限制次数都可以不一样)。。但是注解这个东西自从培训结束后没有在用到过,决定还是再复习下

package com.mzd.redis_springboot_mybatis_mysql.limit;
import org.springframework.core.ordered;
import org.springframework.core.annotation.order;
import java.lang.annotation.*;
/**
 * @retention:注解的保留位置
 * @retention(retentionpolicy.source) //注解仅存在于源码中,在class字节码文件中不包含
 * @retention(retentionpolicy.class) // 默认的保留策略,注解会在class字节码文件中存在,但运行时无法获得,
 * @retention(retentionpolicy.runtime) // 注解会在class字节码文件中存在,在运行时可以通过反射获取到
 */
@retention(retentionpolicy.runtime)
/**
 * @target:注解的作用目标
 * @target(elementtype.type) //接口、类、枚举、注解
 * @target(elementtype.field) //字段、枚举的常量
 * @target(elementtype.method) //方法
 * @target(elementtype.parameter) //方法参数
 * @target(elementtype.constructor) //构造函数
 * @target(elementtype.local_variable) //局部变量
 * @target(elementtype.annotation_type) //注解
 * @target(elementtype.package) ///包
 */
@target(elementtype.method)
/**
 * @document 说明该注解将被包含在javadoc中
 */
@documented
/**
 * ordered接口是由spring提供的,为了解决相同接口实现类的优先级问题
 */
//最高优先级- - - 个人觉得这个在这里没必要加
//@order,使用注解方式使类的加载顺序得到控制
@order(ordered.highest_precedence)
public @interface requesttimes {
 //单位时间允许访问次数 - - -默认值是2
 int count() default 2;
 //设置单位时间为1分钟 - - - 默认值是1分钟
 long time() default 60 * 1000;
}

ordered:

1、接口内容:我们可以打开这个接口查看它的源码

SpringBoot 防止接口恶意多次请求的操作

我们可以看到这个接口中只有一个方法两个属性,一个是int的最小值,另一个是int的最大值

2、ordercomparator接口: priorityordered是个接口,是ordered接口的子类,并没有实现任何方法

SpringBoot 防止接口恶意多次请求的操作

这个comparator方法的逻辑大致是:

priorityordered的优先级高于ordered

如果两个都是ordered或者priorityordered就比较他们的order值,order值越大,优先级越小

第二步:定义一个aop

package com.mzd.redis_springboot_mybatis_mysql.limit;
import com.mzd.redis_springboot_mybatis_mysql.bean.generator.student;
import org.aspectj.lang.joinpoint;
import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.before;
import org.aspectj.lang.annotation.pointcut;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.data.redis.core.redistemplate;
import org.springframework.stereotype.component;
import org.springframework.web.context.request.requestcontextholder;
import org.springframework.web.context.request.servletrequestattributes;
import javax.servlet.http.httpservletrequest;
import java.util.concurrent.timeunit;
//使用@aspect注解将一个java类定义为切面类
@aspect
@component
public class requesttimesaop {
 @autowired
 private redistemplate<string, string> redistemplate;
 //切面范围
 @pointcut("execution(public * com.mzd.redis_springboot_mybatis_mysql.controller.*.*(..))")
 public void webpointcut() {
 }
 @before("webpointcut() && @annotation(times)")
 /**
  * joinpoint对象封装了springaop中切面方法的信息,在切面方法中添加joinpoint参数,就可以获取到封装了该方法信息的joinpoint对象.
  */
 public void ifovertimes(final joinpoint joinpoint, requesttimes times) {
  try {
   //java.lang.object[] getargs():获取连接点方法运行时的入参列表;
   //signature getsignature() :获取连接点的方法签名对象;
   //java.lang.object gettarget() :获取连接点所在的目标对象;
   //java.lang.object getthis() :获取代理对象本身;
   //####################################################################
   /**
    * 比如:获取连接点方法运行时的入参列表
    * 不足:如果连接点方法中没有request参数的话,就没法获取request,如果不做处理的话,会报空指针异常的
    * 但是所有请求怎么可能没有request
    */
//   object[] objects = joinpoint.getargs();
//   httpservletrequest request = null;
//   for (int i = 0; i < objects.length; i++) {
//    if (objects[i] instanceof httpservletrequest) {
//     request = (httpservletrequest) objects[i];
//     break;
//    }
//   }
   //####################################################################
   /**
    * 另一种获取request
    */
   servletrequestattributes attributes = (servletrequestattributes) requestcontextholder.getrequestattributes();
   httpservletrequest request = attributes.getrequest();
   string ip = request.getremoteaddr();
   string url = request.getrequesturl().tostring();
   string key = "ifovertimes".concat(url).concat(ip);
   //访问次数加一
   long count = redistemplate.opsforvalue().increment(key, 1);
   //如果是第一次,则设置过期时间
   if (count == 1) {
    redistemplate.expire(key, times.time(), timeunit.milliseconds);
   }
   if (count > times.count()) {
    request.setattribute("ifovertimes", "true");
   } else {
    request.setattribute("ifovertimes", "false");
   }
  } catch (exception e) {
   e.printstacktrace();
  }
 }
}

提问:就是在aop方法中返回的值在controller层值如何才能获得,比如:ifovertimes这个方法返回的string类型的值,那我在controller层如何获得这个值。我现在是将这个值放在了request域里面,不知道有没有别的更好的值。。。求大神帮助啊。。。

第三步:写一个测试接口

 @requesttimes(count = 3, time = 60000)
 @requestmapping("hello.do")
 public string hello(string username, httpservletrequest request) {
  system.out.println(request.getattribute("ifovertimes"));
  if (request.getattribute("ifovertimes").equals("false")) {
   system.out.println(username);
   return "hello redis_springboot_mybatis_mysql";
  }
  return "http请求超出设定的限制";
 }

总结:

这是一个完全可以跑的例子,当然,springboot集成redis这里就不讲了。。。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持。如有错误或未考虑完全的地方,望不吝赐教。