Go语言视频零基础入门到精通

javalearner

在很多对安全性要求较高的项目中，需要提供至少一种对整个项目的安全控制方案，常用的比如身份认证、访问控制、 安全审计等等。由于设计不合理而导致的安全问题可能会给项目带来非常大的隐患，正是因为如此，安全问题也得到了广大web项目开发者的重视，尤其是在电子 政务和电子商务的开发中，更是需要提供一定层次上的安全性要求。

    本文的重点在于实现一种防止恶意刷新页面的方法，笔者在实现该功能时，查找了很 多资料并且进行了多次讨论协商，提出了这种针对特定需求的，独立性较高的方案。

下面，我们来具体说一下客户的需求。
    该功能是在某电子政务的安全审计子系统中要求实现的一个功能，因为安全审计子系统涉及多方面的内容，包括外网访问日志，专网和内网办公日志，数据库操作日 志等等的控制和查询等等，通过这些功能，可以提供给管理员各种接口，从而可以查看系统的使用状况，并对误操作或者恶意操作进行有效追踪和审计。而外网作为 电子政务的门户，是为广大公众提供访问的接口，那么保证其正常浏览是作为电子政务系统中不可或缺的功能需求，因此，实现防止恶意刷新的功能便是提供良好功能保障的众多手段中的一种。   
  
   
   
     
   

     
   
  
     这里所说的恶意刷新并不是指网络上通常所指的如何通过javascript脚 本来屏蔽F5键等方案，而是通过过滤机制，由程序实现的一种对某次会话中的恶意访问的控制，该方案中制定的规则是：来自某一客户的访问如果在10秒中内超 过10次则被假设为恶意访问。这样的方案也是比较合理的，既避免了恶意用户使用F5键来频繁刷新某一固定页面，也防止了用户漫无目的地乱点页面。同时，该方案还提供了辅助功能，在规则设定方面比较灵活，默认为10次/10秒，这两个参数是可以通过程序来设置的；在恶意控制方面，如果用户的访问违反了该规则，则通过过滤器机制提取该用户的IP地址，将其置为拒绝提供服务的IP列表中，将拒绝再次为来自该IP的请求提供服务。

下面，我们来具体说明一下该方案的实现方法。
首先，从整个方案的实施体系来讲，我们提取出如下的控制流程。


从上图可以看出，来自客户端的请求首先要经过IP过滤器的过滤，只有不在恶意IP列表中的IP地址的请求才有可能被响应，然后还要经过恶意刷新过滤器的验证才能得到服务器的最终响应。如果该IP在10秒内连续请求的次数达到了10次，那么，它将被记入到恶意IP列表中，将不会通过IP过滤器的验证，不会得到服务器的响应，从而，我们就实现了对恶意用户的过滤。当然，通过IP过滤器的作用，我们还可以将某些IP直接列入黑名单中，比如某些具有攻击性的网站的IP地址或者曾经通过网络入侵检测软件的诊断，将危险IP也加入黑名单，这样，可以提高我们的应用的安全性和可用性。     接下来，我们通过代码来看一下如何具体实现我们的功能。通过上面的流程图，我们可以清晰看到，在应用中，我们配置了两个过滤器（关于过滤器的原理和实现，请读者参考相关资料），当然，我们也可以将其写在一个过滤器的doFilter()方法中。

本文方案的实现中采用了两个过滤器，下面我们来简单看一下IP过滤器。以下是具体的代码实现，通过代码中的注释，可以清楚看到我们的实现思路。

1. HttpServletRequest req = (HttpServletRequest)request;
   
2. HttpServletResponse res = (HttpServletResponse)response;
   
3. String ip = request.getRemoteAddr(); //得到客户端IP地址
   
4.   if(!req.getRequestURI().toUpperCase().equals("ERR.JSP")){
   
5.   IP ipControl = new IP(); //生成一个IP类的事例
   
6.   try{
   
7.     // getDangerousIP(ip)将查询指定IP是否在IP黑名单的数据库中
   
8.     if((ip != null )&&(ipControl.getDangerousIP(ip) !=0)){
   
9.       res.sendRedirect("/err.jsp?errmsg=ip");
   
10.     } else{
    
11.       //如果该IP安全，则继续执行
    
12.       chain.doFilter(request, response);
    
13.     }
    
14. }catch (ServletException ex){
    
15.     ex.printStackTrace();
    
16. }catch (IOException ex){
    
17.    ex.printStackTrace();
    
18. }catch (Exception ex){
    
19.     ex.printStackTrace();
    
20. }
    
21. finally...{
    
22. ipControl.closeConn();//关闭数据库连接
    
23. }
    

复制代码

     下面，我们来着重讨论如何实现恶意刷新的过滤器。因为我们的需求是在任何的10秒中记录请求数而不是在以10秒为一个时间段，那么就需要保证时间的连续性，鉴于此需求，我们需要保存用户连续10次请求的时间，如果其最后一次的请求时间与第一次的时间差小于10秒并且次数已经达到10次，则违背设定规则，我们设计了下面的类来保存用户的访问时间序列。

1. public class ArrayTime{
   
2.   private long[] time;
   
3.   private int length = 10; //默认为十次（10s内刷新10次则违反规则）
   
4.   public ArrayTime(){
   
5.   }
   
6.   public void init() {
   
7.    time = new long[length];
   
8.   }
   
9.   public int getLength() {
   
10.    return this.length;
    
11.   }
    
12.   public void setLength(int len)
    
13.   {
    
14.    this.length = len;
    
15.   }
    
16.   public long getLast() {
    
17.    return this.time[length-1];
    
18.   }
    
19.   public long getFirst() {
    
20.    return this.time[0];
    
21.   }
    
22.   public long getElement(int i) {
    
23.    return time[i];
    
24.   }
    
25.   public void insert(long nextTime) {
    
26.    if (this.getLast() != 0)//数组已经满了
    
27.    {
    
28.     //去掉首元素，将数组元素顺序前移，nextTime插到最后
    
29.     for(int i = 0 ;i < this.length-1;i++) {
    
30.       time[i] = time[i+1];
    
31.     }
    
32.     this.time[length-1] = nextTime;
    
33.    } else {
    
34.      //插到下一个，不用排序
    
35.      int j=0;
    
36.      while(time[j] != 0) {
    
37.       j++;
    
38.      }
    
39.      time[j] = nextTime;
    
40.    }
    
41.   }
    
42. }
    

复制代码

这里要注意的是，因为我们为管理员提供了规则设置的接口，所以保存时间序列的数组长度是可设定的。下面是来自客户端的访问者类的实现：

1. public class Visitor {
   
2.   /**//* Creates a new instance of Visitor
   
3.    *外网访问者，以sessionID作为标识
   
4.    *违反访问规则将其IP列为受限IP，拒绝访问
   
5.    */
   
6.   private String sessionID = null;
   
7.   private ArrayTime requestTimeQueue= new ArrayTime();
   
8.   public Visitor() {
   
9.   }
   
10.   public void setSessionID(String sessionID)
    
11.    {
    
12.     this.sessionID = sessionID;
    
13.   }
    
14.   public String getSessionID()
    
15.   {
    
16.     return this.sessionID;
    
17.   }
    
18.   public void setRequestTimeQueue(ArrayTime requestTimeQueue)
    
19.    {
    
20.      this.requestTimeQueue = requestTimeQueue;
    
21.    }
    
22.   public ArrayTime getRequestTimeQueue()
    
23.   {
    
24.     return this.requestTimeQueue;
    
25.   }
    
26. }
    

复制代码

      该类中采用了访问者的会话ID来标识来自客户端的请求，读者可以很方便地修改该标识，比如修改为注册会员的用户名，这样，就可以实现对会员的恶意访问的屏蔽，同时这样的好处还在于，可以屏弃对session和cookies的依赖，因为如果用户浏览器如果禁用cookie，通常利用session和 cookies实现的恶意刷新就失去了作用。虽然，我们这样做也可能是一种消耗内存的方式，但是，的确是一种值得采用并进行优化的折中方案。
最后，也是最关键的就是我们如何来通过过滤器实现对恶意用户的请求进行屏蔽。下面是该过滤器的doFliter()方法的核心部分的实现。

1. //---------------防止恶意刷新的过滤器--------
   
2. HttpServletRequest req = (HttpServletRequest)request;
   
3. HttpServletResponse res = (HttpServletResponse)response;
   
4. String sessionID = ((HttpServletRequest)request).getSession().getId();//会话ID
   
5. Date now =new Date();
   
6. Visitor vis = (Visitor) visitors.get(sessionID);//通过sessionID查找访问者，
   
7. if(vis!= null)//找到访问者，则说明该用户为再次访问
   
8. {
   
9.   //小于10秒，但访问超过10次
   
10.   vis.getRequestTimeQueue().insert(now.getTime());//插入当前请求时间
    
11.   //得到最后一次和第一次的访问时间差
    
12.   Long span = vis.getRequestTimeQueue().getLast() - vis.getRequestTimeQueue().getFirst();
    
13.   if(span < interval && vis.getRequestTimeQueue().getLast() != 0){
    
14.    //将该用户加入黑名单
    
15.    IP ip = new IP();
    
16.    ip.setIP(request.getRemoteAddr());
    
17.    //得到当前时间
    
18.    Calendar cal = Calendar.getInstance();
    
19.    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
20.    String time=formatter.format(cal.getTime());
    
21.    ip.setComments("刷新太快，IP已经被封锁");
    
22.    try {
    
23.      ip.insertIP();
    
24.       res.sendRedirect("err.jsp?errmsg=refresh");
    
25.      return;
    
26.    }catch(Exception e){
    
27.      e.printStackTrace();
    
28.    }finally{
    
29.      ip.closeConn();}
    
30.    }
    
31. }else{
    
32.     //当前访问者为初次访问
    
33.     ArrayTime timeQueue = new ArrayTime();
    
34.     timeQueue.setLength(maxCount);
    
35.     timeQueue.init();
    
36.     vis=new Visitor();
    
37.     vis.setSessionID(sessionID);
    
38.     vis.setRequestTimeQueue(timeQueue);
    
39.     vis.getRequestTimeQueue().insert(now.getTime());
    
40.     visitors.put(sessionID,vis);
    
41.   }
    

复制代码

本文中的实现方案为管理员提供了灵活的接口，可以根据实际需要设置相应规则，刷新过滤器中的两个参数都是可设置的，比如： //以下两个值可从文件或数据库设置，从而达到参数的可设置
private static long interval= GlobalConfig.getInt("refresh.interval",10000); //默认10秒钟
private static int maxCount = GlobalConfig.getInt("refresh.count",10);//默认最大访问次数     该方案的实现中采用了保存时间序列的方案，而这样，就要在内存中开辟一个可变可控的数组，在一定程度上浪费了资源，但是，也提供了在保证连续时间下防止恶意刷新的功能，并且可以屏弃对session和cookies的依赖，达到完全的可自控，保证了有效性。同时，提供了IP过滤机制来保证功能体系的完善和有效，目前该方案在项目中应用良好。  

  
  
   
   

     
   

     
   
  

复制代码