怎么做ip过滤

问题

为了防止您的网站被恶意攻击，你会对系统设置一个ip黑名单来挡住那些恶意攻击的的ip。怎样才能实现一个高效的ip过滤呢。
发散思维的方式写一个ip过滤的

方案一：布隆过滤器

布隆过滤器

• 创建一个位图（java用bitset实现，生成中应该用的是redis的位图）。
• 一个ip用N种hash算法生成N种int值，分别赋值到位图中。
• 新来个ip直接在用这N种hash算出int值，在位图种查找判断是否存在。若都存在就认为这ip是要过滤的ip。

public class BloomIp {
    /**
     * bitSet只能是正数设个size保证hash算的是正数
     */
    private static final int SIZE = 1<<24;
    BitSet bitSet=new BitSet(SIZE);
    Hash[] hashs=new Hash[3];
    private static final int seeds[]=new int[]{3,5,7};
    public static void main(String[] args) {
        String ip="192.168.1.1";
        BloomIp bloomDemo=new BloomIp();
        System.out.println(ip+"是否在列表中： "+bloomDemo.contains(ip));
        bloomDemo.add(ip);
        System.out.println(ip+"是否在列表中： "+bloomDemo.contains(ip));
        ip="192.168.1.2";
        System.out.println(ip+"是否在列表中： "+bloomDemo.contains(ip));
        bloomDemo.add("255.255.255.255");

    }
    public BloomIp(){
        for (int i = 0; i < seeds.length; i++) {
            hashs[i]=new Hash(seeds[i]);
        }
    }
    public void add(String string){
        for(Hash hash:hashs){
            bitSet.set(hash.getHash(string),true);
        }
    }
    public boolean contains(String string){
        boolean have=true;
        for(Hash hash:hashs){
            have&=bitSet.get(hash.getHash(string));
        }
        return have;
    }
    class Hash{
        public int getSeed() {
            return seed;
        }

        private int seed = 0;
        public Hash(int seed){
            this.seed=seed;
        }
        public int getHash(String string){
            int val=0;
            int len=string.length();
            for (int i = 0; i < len; i++) {
                val = val * seed + string.charAt(i);
            }
            return val&(SIZE-1);
        }
    }

}

局限性

1.假如ipA在位图中是[2,5,8],ipB在位图中是[3,5,9]，一个不应该被过滤的ipC在位图是[3,5,8]，就会涉及到二次过滤白名单的解决方案。
2.ip黑明单的ip增加是没有问题，但是减少；ip就没法做，例如ipA在位图中是[2,5,8],ipB在位图中是[3,5,9]删除ipB会很麻烦。
只能全量重新编译位图或要涉及很多计算判断。

方案二 ip转int + 位图实现。

ip是什么0-255.0-255.0-255.0-255
单看0-255 说白了就是2^8就能表示。
0-255.0-255.0-255.0-255也就是(2^8)* (2^8)* (2^8)* (2^8)*=232。
int占4个字节32位正好也是2^32.
一个ip完全可以转成一个int。

public class BitIp {
    /**
     * int 范围是 -2^31——2^31-1
     * bitset只能存正数0-2^31-1，所以要两个bitset
     */
    private static final int SIZE = 1 << 31 - 1;
    /**
     * 这里存正数
     */
    BitSet aSet = new BitSet(SIZE);
    /**
     * 这里存负数
     */
    BitSet bSet = new BitSet(SIZE);

    public static void main(String[] args) {
        String ip = "192.168.1.1";
        BitIp bitIp = new BitIp();
        System.out.println(ip + "是否在列表中： " + bitIp.contains(ip));
        bitIp.add(ip);
        System.out.println(ip + "是否在列表中： " + bitIp.contains(ip));
        bitIp.delete(ip);
        System.out.println(ip + "是否在列表中： " + bitIp.contains(ip));
        ip = "192.168.1.2";
        System.out.println(ip + "是否在列表中： " + bitIp.contains(ip));

    }

    public void add(String ip) {
        int i = ip2Int(ip);
        BitSet tempSet = i >= 0 ? aSet : bSet;
        tempSet.set(i >= 0 ? i : -(i + 1), true);
    }


    public void delete(String ip) {
        int i = ip2Int(ip);
        BitSet tempSet = i >= 0 ? aSet : bSet;
        tempSet.set(i >= 0 ? i : -(i + 1), false);
    }

    public boolean contains(String ip) {
        int i = ip2Int(ip);
        BitSet tempSet = i >= 0 ? aSet : bSet;
        return tempSet.get(i >= 0 ? i : -(i + 1));
    }

    public static int ip2Int(String ip) {
        String[] split = ip.split("\\.");
        int result = 0;
        for (String s : split) {
            int i = Integer.parseInt(s);
            result = (result << 8) + i;
        }
        return result;
    }

}

优点，可以做增删ip。不需要太多的运算。
缺点，占用了比布隆过滤器更多的内存。（ip分散小，不多的话差不太多，可以看看bitset的设计方案。）
最多内存占用量是2^32 b
转化byte是2^29 byte
转化kb是2^19 kb
转化mb是2^9 mb
也就是512mb，其实是可以接受的。

代码 https://github.com/jlhuang9/iptest