检查 IP 地址是否在多个可能的子网中

Question

我正在解析 Apache 日志并想检查一个 IP 地址是否属于大约 300 个可能的子网列表 (https://github.com/client9/ipcat)。

• 互联网流量中有很多不同的 IP（我不知道它们属于哪个子网）。
• 我正在使用 Apache Commons SubnetUtils 包来存储子网。
• 将来自 300 个子网的所有可能 IP 存储在哈希图中会占用太多内存。
• 对每个 IP 的每个 SubnetUtil 进行迭代（即使使用 HashMap 缓存用于之前的查找）非常慢。

还有什么我可以在这里做的吗？

Answer 1

您可以使用子网构建树结构 - 它可以一点一点地构建。这会将检查从 300 减少到最多 32（假设 IPv4），但在大多数情况下要少得多。 （因为它要么在几位之后不匹配，要么在子网掩码的平均长度处匹配）

这是一个简单的二叉树实现。您可能想用一些函数来装饰它，以更常见的"a.b.c.d/e" 格式解析子网。

public class SubnetTree {
    private SubnetTree one, zero;
    private boolean terminating;

    public void addSubnet(int net, int bits) {
        if (terminating) {
            // If this node is already terminating, then no need to add
            // subnets that are more specific
            return;
        }
        if (bits > 0) {
            boolean bit = ((net >>> 31) & 1) == 1;
            if (bit) {
                if (one == null) {
                    one = new SubnetTree();
                }
                one.addSubnet(net << 1, bits - 1);
            } else {
                if (zero == null) {
                    zero = new SubnetTree();
                }
                zero.addSubnet(net << 1, bits - 1);
            }
        } else {
            terminating = true;
        }
    }

    public boolean isInRange(int address) {
        if (terminating) {
            return true;
        }
        boolean bit = ((address >>> 31) & 1) == 1;
        if (bit) {
            if (one == null) {
                return false;
            } else {
                return one.isInRange(address << 1);
            }
        } else {
            if (zero == null) {
                return false;
            } else {
                return zero.isInRange(address << 1);
            }
        }
    }
}

对此代码的一个非常简单的测试：

public static void main(String[] args) {
    SubnetTree tree = new SubnetTree();
    tree.add(Integer.parseUnsignedInt("01100110000000000000000000000000", 2), 8);
    System.out.println("true: " + tree.isInRange(Integer.parseUnsignedInt("01100110000000000000100010000101", 2)));
    System.out.println("false: " + tree.isInRange(Integer.parseUnsignedInt("01101110000000000000100010000101", 2)));

    tree.add(Integer.parseUnsignedInt("01001110000000000000000000000000", 2), 6);
    System.out.println("true: " + tree.isInRange(Integer.parseUnsignedInt("01100110000000000000100010000101", 2)));
    System.out.println("false: " + tree.isInRange(Integer.parseUnsignedInt("01101110000000000000100010000101", 2)));
    System.out.println("true: " + tree.isInRange(Integer.parseUnsignedInt("01001110100000000000000000000000", 2)));
    System.out.println("true: " + tree.isInRange(Integer.parseUnsignedInt("01001100100000000000000000111111", 2)));
}

Answer 2

您基本上想为所有子网构建一个 Trie（前缀树）。在其中的搜索将非常快，最坏的情况是最长子网前缀的长度（最终为 32）。在内存方面它也非常有效。

以二进制表示形式考虑您的子网，因此树将存储它。然后，IP 地址也应转换为二进制，并将树用于搜索。到达叶子节点时，检查它是否是有效的子网。

这是一个相当完整的实现/示例：

import java.util.Arrays;

public class CheckIpAdrBelongsToSubnet {
  private static final String [] CIDR_SUBNETS = {"192.5.0.0/16", "10.10.0.0/16"};

  public static void main(String ... ips) {
    BinaryTrieNode root = createBinaryTrieFromCidrs(CIDR_SUBNETS);

    for(String ip :ips) {
      System.out.println(ip + " belongs to a subnet in list: " + ipBelongsToCidrs(ip, root));
    }
  }

  static boolean ipBelongsToCidrs(String ipv4, BinaryTrieNode root) {
    BinaryIpV4 bipv4 = new BinaryIpV4(ipv4);
    BinaryTrieNode current = root;
    for(boolean b : bipv4.getBinIp()) {
      BinaryTrieNode nextCurr = current.getNode(b);
      if(nextCurr == null) {
        return current.isEndOfValidPrefix();
      } else {
        current = nextCurr;
      }
    }
    return false;
  }

  static BinaryTrieNode createBinaryTrieFromCidrs(String [] cidrs) {
    BinaryTrieNode root = new BinaryTrieNode();

    for (String cidr : cidrs) {
      String ipv4 = cidr.split("/")[0];
      int prefixLength = Integer.parseInt(cidr.split("/")[1]);
      BinaryIpV4 bipv4 = new BinaryIpV4(ipv4, prefixLength);

      BinaryTrieNode current = root;
      for(boolean b : bipv4.getBinIp()) {
        BinaryTrieNode nextCurr = current.getNode(b);
        if(nextCurr == null) {
          nextCurr = new BinaryTrieNode();
          current.setNode(b, nextCurr);
        }
        current = nextCurr;
      }
      current.setEndOfValidPrefix(true);
    }

    return root;
  }

  public static class BinaryIpV4 {
    boolean [] binIp;

    BinaryIpV4(String ipv4) {
      translateCidrToBinPrefix(ipv4,32);
    }

    BinaryIpV4(String ipv4, int prefixLength) {
      translateCidrToBinPrefix(ipv4,prefixLength);
    }

    void translateCidrToBinPrefix(String ipv4, int prefixLength) {
      String [] bytes = ipv4.split("\\.");
      binIp = new boolean [prefixLength];
      int idx = 0;

      for(String b : bytes) {
        int by = Integer.parseUnsignedInt(b);
        String binByte = getBinaryString(by);

        for(int i = 0; i < binByte.length() ; i++) {
          binIp[idx++] = binByte.charAt(i)=='1';

          if(idx >= prefixLength) {
            return;
          }
        }
      }
    }

    public boolean[] getBinIp() {
      return binIp;
    }

    String getBinaryString(int b) {
      return String.format("%8s", Integer.toBinaryString(b & 0xFF)).replace(' ', '0');
    }

    public String toString() {
      return Arrays.toString(binIp);
    }
  }

  public static class BinaryTrieNode {
    private boolean isEndOfValidPrefix=false;

    private BinaryTrieNode zeroNode;
    private BinaryTrieNode oneNode;

    public boolean isEndOfValidPrefix() {
      return isEndOfValidPrefix;
    }
    public void setEndOfValidPrefix(boolean isEndOfValidPrefix) {
      this.isEndOfValidPrefix = isEndOfValidPrefix;
    }
    public BinaryTrieNode getNode(boolean b) {
      return b?oneNode:zeroNode;
    }
    public void setNode(boolean b, BinaryTrieNode node) {
      if(b) {
        this.oneNode = node;
      } else {
        this.zeroNode = node;
      }

    }
  }
}

Answer 3

这是我要做的：

• 提前设置任何子网不得与任何其他子网重叠的策略。
• 按起始 IP（一次）升序对子网进行排序。
• 对于每个 IP，对数组执行二进制搜索，返回最后一个小于或等于该 IP 的 IP。
• 检查那个子网。

在 IP 字符串初始转换为整数之后，这是 O(log2(n)) 次简单的数值比较，其中 n 为 300（大约为 9）加上一个按位与和一个额外的数值比较。

要将字符串转换为 C 中的整数，您可以这样做：

struct in_addr addr;
int ip = inet_aton(stringAddress, &addr);

对于每个 IP（子网和您正在检查的 IP）。而对于面具：

uint32_t mask_val = ~((1 << (32 - nbits)) - 1);
// e.g. a mask of 30 gives you ~[[1 << 2 == 0b100] - 1 = 0b11] = 0b111...100

我认为大多数其他语言都有类似的功能。

然后你会将它们与：

if (ip & mask == subnet) { // match }