CIDR网络地址、广播地址、网段区间计算说明与计算工具

开始

好久没有看计算网络，感觉已经完全返给老师了。

最近，有同事遇到个问题，网络一直不对，又开始重新看一下。

相信很多朋友长时间不看也忘了，所以，这里记录一下，并提供了一个工具类用来计算相关值。

希望帮助新学习的朋友学习、已经忘了的朋友重新回忆。

觉得自己理解到位的朋友，可以尝试一下下面的问题。

问题

我的IPv4地址是：172.17.1.6，子网掩码是：255.255.252.0

请问：

1. 我和172.17.0.6在同一网段吗？172.17.2.6呢？172.17.3.6呢？172.17.4.6呢？
2. 我所在网络的网络地址是多少？网络位数是多少？
3. 我所在网络的广播地址是多少？
4. 我所在网络的最小主机IP地址是多少？
5. 我所在的网络最大主机IP地址是多少？

上面的问题你能回答几个？答对了几个？

参考答案

1. 172.17.1.6和172.17.0.6、172.17.2.6、172.17.3.6是同一网段，和172.17.4.6不是同一网段
2. 我所在网络的网络地址：10101100000100010000000000000000(172.17.0.0/22)
3. 我所在网络的广播地址：10101100000100010000001111111111(172.17.3.255)
4. 我所在网络的最小主机IP地址：10101100000100010000000000000001(172.17.0.1)
5. 我所在的网络最大主机IP地址：10101100000100010000001111111110(172.17.3.254)

答案解析

首先算网络地址:
我的IP & 子网掩码就是我所在的网络地址：
我的地址：10101100000100010000000100000110(172.17.1.6)
子网掩码：11111111111111111111110000000000(255.255.252.0)
与有0为0：10101100000100010000000000000000(172.17.0.0)

网络位数，数子网掩码前面1的个数:22，因此网络号可以写成：172.17.0.0/22，很多网策支持这样配置。

广播地址是主机位全为1的地址，因此把网络地址中的主机位全换为1即可：
网络位数是22，所以主机位是10位：10101100000100010000001111111111(172.17.3.255)

最小的主机地址是网络地址+1：10101100000100010000000000000001(172.17.0.1)
最大的主机地址是广播地址-1：10101100000100010000001111111110(172.17.3.254)

有了最小的主机地址和最大的主机地址，现在再看第一个问题，是不是清晰了。

这其中最大的误区就是，一晃眼就认为172.17.1.6的网段是172.17.1.0
这是没有CIDR，在子网掩码为：255.255.255.0时才成立

计算工具

package vip.meet.network.ip;

import lombok.extern.slf4j.Slf4j;

import java.math.BigInteger;

/**
 * CIDR
 * 网络中:
 * 全为0的是:网络地址(最小地址)
 * 全为1的是:广播地址(最大地址)
 * 最小可用地址=网络地址+1
 * 最大可用地址=广播地址-1
 * <p>
 * 私有地址:
 * A类地址范围:10.0.0-10.255.255.255
 * B类地址范围:172.16.0.0-172.31.255.555
 * C类地址范围:192.168.0.0-192.168.255.255
 */
@Slf4j
public class IpCalculateHelper {

    /**
     * 根据主机IP和子网掩码计算网络地址 ip & mask
     * <p>
     * 198.1.33.205 :11000110000000010010000111001101
     * 255.255.252.0:11111111111111111111110000000000
     * &
     * 198.1.32.0/22:11000110000000010010000000000000
     *
     * @param netIp 要计算的ip 198.1.33.205
     * @param mask  子网掩码 255.255.252.0
     * @return 网络地址 198.1.32.0
     */
    public static String getIPV4CIDRNet(String netIp, String mask) {
        String ipv4CIDRBinary = getIPV4CIDRBinary(netIp, mask);
        return binaryIp2NetIp(ipv4CIDRBinary);
    }

    /**
     * 获取网络二进制地址
     *
     * @param netIp 198.1.33.205
     * @param mask  55.255.252.0
     * @return 11000110000000010010000000000000
     */
    public static String getIPV4CIDRBinary(String netIp, String mask) {
        BigInteger ipBin = new BigInteger(getIPBinary(netIp), 2);
        BigInteger maskBin = new BigInteger(getIPBinary(mask), 2);
        BigInteger result = ipBin.and(maskBin);
        String string = result.toString(2);
        return "0".repeat(32 - string.length()) + string;
    }

    /**
     * 二进制转ip转网络ip
     *
     * @param binaryIp 二进制ip 11000110000000010010000000000000
     * @return ip 198.1.32.0
     */
    public static String binaryIp2NetIp(String binaryIp) {
        int length = binaryIp.length();
        if (length > 32) {
            throw new RuntimeException("非法ip长度:" + binaryIp);
        }
        String pad = "0".repeat(32 - length) + binaryIp;
        return Integer.valueOf(pad.substring(0, 8), 2) + "." +
                Integer.valueOf(pad.substring(8, 16), 2) + "." +
                Integer.valueOf(pad.substring(16, 24), 2) + "." +
                Integer.valueOf(pad.substring(24), 2);
    }

    /**
     * 二进制ip转ip
     *
     * @param netIp 198.1.32.0
     * @return binary ip 二进制ip 11000110000000010010000000000000
     */
    public static String getIPBinary(String netIp) {
        String[] parts = netIp.split("\\.");
        if (parts.length != 4) {
            throw new RuntimeException("非法ipv4:" + netIp);
        }
        StringBuilder sb = new StringBuilder();
        for (String part : parts) {
            BigInteger integer = new BigInteger(part, 10);
            String partIp = integer.toString(2);
            sb.append("0".repeat(8 - partIp.length())).append(partIp);
        }
        return sb.toString();
    }

    /**
     * 根据子网掩码算网络位数
     *
     * @param mask 子网掩码 255.255.252.0
     * @return 网络位数 22
     */
    public static int getNetBitFromMask(String mask) {
        String binString = getIPBinary(mask);
        int count = 0;
        for (int i = 0; i < binString.length(); i++) {
            if (binString.charAt(i) != '1') {
                break;
            }
            count++;
        }
        return count;
    }

    /**
     * 获取二进制子网掩码
     *
     * @param netBit 网络位数
     * @return 二进制子网掩码
     */
    public static String getMaskBinaryFromNetBit(int netBit) {
        if (netBit < 1 || netBit >= 32) {
            throw new RuntimeException("非法网络位数:" + netBit);
        }
        return "1".repeat(netBit) + "0".repeat(32 - netBit);
    }

    /**
     * 获取子网掩码
     *
     * @param netBit 网络位数
     * @return 子网掩码
     */
    public static String getMaskFromNetBit(int netBit) {
        if (netBit < 1 || netBit >= 32) {
            throw new RuntimeException("非法网络位数:" + netBit);
        }
        String maskBinary = "1".repeat(netBit) + "0".repeat(32 - netBit);
        return binaryIp2NetIp(maskBinary);
    }

    /**
     * 获取广播地址
     *
     * @param binaryCIDR cidr网络 11000110000000010010000000000000
     * @param netBit     网络位数 22
     * @return 广播地址 11000110000000010010001111111111
     */
    public static String getBroadcast(String binaryCIDR, int netBit) {
        if (netBit < 1 || netBit >= 32) {
            throw new RuntimeException("非法网络位数:" + netBit);
        }
        return binaryCIDR.substring(0, netBit) + "1".repeat(32 - netBit);
    }

    /**
     * 计算最小主机地址
     *
     * @param binaryCIDR CIDR网络地址 11000110000000010010000000000000
     * @return 最小主机地址 1100011000000001001000000000000
     */
    public static String minHostIp(String binaryCIDR) {
        return binaryCIDR.substring(0, 31) + "1";
    }

    /**
     * 最大主机地址
     *
     * @param binaryCIDR CIDR网络地址 11000110000000010010000000000000
     * @param netBit     网络位数 22
     * @return 最大主机地址 11000110000000010010001111111110
     */
    public static String maxHostIp(String binaryCIDR, int netBit) {
        if (netBit < 1 || netBit >= 32) {
            throw new RuntimeException("非法网络位数:" + netBit);
        }
        return binaryCIDR.substring(0, netBit) + "1".repeat(31 - netBit) + "0";
    }

    public static void printNetInfo(String netIp, int netBit) {
        if (netBit < 1 || netBit >= 32) {
            throw new RuntimeException("非法网络位数:" + netBit);
        }
        String mask = getMaskFromNetBit(netBit);
        printNetInfo(netIp, netBit, mask);
    }

    public static void printNetInfo(String netIp, String mask) {
        int netBit = getNetBitFromMask(mask);
        printNetInfo(netIp, netBit, mask);
    }

    public static void printNetInfo(String netIp, Integer netBit, String mask) {
        if (netBit == null) {
            netBit = getNetBitFromMask(mask);
        }
        if (netBit < 1 || netBit >= 32) {
            throw new RuntimeException("非法网络位数:" + netBit);
        }
        String ipBinary = getIPBinary(netIp);
        System.out.printf("二进制IP:%s(%s)\n", ipBinary, netIp);
        String maskBinary = getIPBinary(mask);
        System.out.printf("  掩码IP:%s(%s)\n", maskBinary, mask);
        String ipv4CIDRBinary = getIPV4CIDRBinary(netIp, mask);
        System.out.printf("  网络IP:%s(%s/%d)\n", ipv4CIDRBinary,
                binaryIp2NetIp(ipv4CIDRBinary), netBit);
        String broadcast = getBroadcast(ipv4CIDRBinary, netBit);
        System.out.printf("  广播IP:%s(%s)\n", broadcast, binaryIp2NetIp(broadcast));

        String min = minHostIp(ipv4CIDRBinary);
        System.out.printf(" 最小HIP:%s(%s)\n", min, binaryIp2NetIp(min));

        String max = maxHostIp(ipv4CIDRBinary, netBit);
        System.out.printf(" 最大HIP:%s(%s)\n", max, binaryIp2NetIp(max));
    }
}

测试

 @Test
public void printNetInfo() {
    IpCalculateHelper.printNetInfo("10.2.2.7", 20);
    System.out.println("--------------");
    IpCalculateHelper.printNetInfo("172.17.1.6", "255.255.252.0");
    System.out.println("--------------");
    IpCalculateHelper.printNetInfo("192.168.3.3", 21);
}