Go: Convert IP to CIDR

Golang-IP-to-CIDR

/ Convert IPv4 range into CIDR
func iPv4RangeToCIDRRange(ipStart string, ipEnd string) (cidrs []string, err error) {

	cidr2mask := []uint32{
		0x00000000, 0x80000000, 0xC0000000,
		0xE0000000, 0xF0000000, 0xF8000000,
		0xFC000000, 0xFE000000, 0xFF000000,
		0xFF800000, 0xFFC00000, 0xFFE00000,
		0xFFF00000, 0xFFF80000, 0xFFFC0000,
		0xFFFE0000, 0xFFFF0000, 0xFFFF8000,
		0xFFFFC000, 0xFFFFE000, 0xFFFFF000,
		0xFFFFF800, 0xFFFFFC00, 0xFFFFFE00,
		0xFFFFFF00, 0xFFFFFF80, 0xFFFFFFC0,
		0xFFFFFFE0, 0xFFFFFFF0, 0xFFFFFFF8,
		0xFFFFFFFC, 0xFFFFFFFE, 0xFFFFFFFF,
	}

	ipStartUint32 := iPv4ToUint32(ipStart)
	ipEndUint32 := iPv4ToUint32(ipEnd)

	if ipStartUint32 > ipEndUint32 {
		log.Fatalf("start IP:%s must be less than end IP:%s", ipStart, ipEnd)
	}

	for ipEndUint32 >= ipStartUint32 {
		maxSize := 32
		for maxSize > 0 {

			maskedBase := ipStartUint32 & cidr2mask[maxSize - 1]

			if maskedBase != ipStartUint32 {
				break
			}
			maxSize--

		}

		x := math.Log(float64(ipEndUint32 - ipStartUint32 + 1)) / math.Log(2)
		maxDiff := 32 - int(math.Floor(x))
		if maxSize < maxDiff {
			maxSize = maxDiff
		}

		cidrs = append(cidrs,  uInt32ToIPv4(ipStartUint32) + "/" +  strconv.Itoa(maxSize))

		ipStartUint32 += uint32(math.Exp2(float64(32 - maxSize)))
	}

	return cidrs, err
}

//Convert IPv4 to uint32
func iPv4ToUint32(iPv4 string ) uint32 {

	ipOctets := [4]uint64{}

	for i, v := range strings.SplitN(iPv4,".", 4) {
		ipOctets[i], _  = strconv.ParseUint(v, 10, 32)
	}

	result := (ipOctets[0] << 24) | (ipOctets[1] << 16) | (ipOctets[2] << 8) | ipOctets[3]

	return uint32(result)
}

//Convert uint32 to IP
func uInt32ToIPv4(iPuInt32 uint32) (iP string) {
	iP =  fmt.Sprintf ("%d.%d.%d.%d",
		iPuInt32 >> 24,
		(iPuInt32 & 0x00FFFFFF)>> 16,
		(iPuInt32 & 0x0000FFFF) >> 8,
		iPuInt32 & 0x000000FF)
	return iP
}

Thank you very much, very useful

You're welcome. Looks like time to add IPv6.

To meet the needs, I have done this first, it should be able to be used for testing

and I found the same implementation in other languages ​​here

https://blog.ip2location.com/knowledge-base/how-to-convert-ip-address-range-into-cidr/

func IpRangeToCIDRRange(ipFrom, ipTo string) ([]string, error) {
	url := "https://www.ipaddressguide.com/cidr"
	if strings.IndexByte(ipFrom, '.') < 0 {
		url = "https://www.ipaddressguide.com/ipv6-cidr"
	}
	resp, err := http.Post(url, "application/x-www-form-urlencoded",
		strings.NewReader("mode=range&ipFrom="+ipFrom+"&ipTo="+ipTo))
	if err != nil {
		return nil, err
	}

	data, err := io.ReadAll(resp.Body)
	_ = resp.Body.Close()
	if err != nil {
		return nil, err
	}

	if e := bytes.Index(data, []byte("</code></pre></div>")); e > 0 {
		if s := bytes.LastIndexByte(data[:e], '>'); s > 0 {
			return strings.Split(string(data[s+1:e]), "\n"), nil
		}
	}
	return nil, errors.New("not find")
}

@P-A-R-U-S @xinternetx

I found a method that works for both ipv4 and ipv6

package main

import (
	"errors"
	"fmt"
	"math/big"
	"net/netip"
	"strings"
)

func main() {
	ss, err := IpRangeToCIDR("172.17.0.0", "172.17.5.0")
	if err != nil {
		panic(err)
	}
	fmt.Println(strings.Join(ss, "\n"))

	ss, err = IpRangeToCIDR("2001:4860:4860:ffff:ffff:ffff:ffff:ffff", "2001:4860:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF")
	if err != nil {
		panic(err)
	}
	fmt.Println(strings.Join(ss, "\n"))
}

func IpRangeToCIDR(start, end string) ([]string, error) {
	ips, err := netip.ParseAddr(start)
	if err != nil {
		return nil, err
	}
	ipe, err := netip.ParseAddr(end)
	if err != nil {
		return nil, err
	}

	isV4 := ips.Is4()
	if isV4 != ipe.Is4() {
		return nil, errors.New("start and end types are different")
	}
	if ips.Compare(ipe) > 0 {
		return nil, errors.New("start > end")
	}

	var (
		ipsInt = new(big.Int).SetBytes(ips.AsSlice())
		ipeInt = new(big.Int).SetBytes(ipe.AsSlice())
		nextIp = new(big.Int)
		maxBit = new(big.Int)
		cmpSh  = new(big.Int)
		bits   = new(big.Int)
		mask   = new(big.Int)
		one    = big.NewInt(1)
		buf    []byte
		cidr   []string
		bitSh  uint
	)
	if isV4 {
		maxBit.SetUint64(32)
		buf = make([]byte, 4)
	} else {
		maxBit.SetUint64(128)
		buf = make([]byte, 16)
	}

	for {
		bits.SetUint64(1)
		mask.SetUint64(1)
		for bits.Cmp(maxBit) < 0 {
			nextIp.Or(ipsInt, mask)

			bitSh = uint(bits.Uint64())
			cmpSh.Lsh(cmpSh.Rsh(ipsInt, bitSh), bitSh)
			if (nextIp.Cmp(ipeInt) > 0) || (cmpSh.Cmp(ipsInt) != 0) {
				bits.Sub(bits, one)
				mask.Rsh(mask, 1)
				break
			}
			bits.Add(bits, one)
			mask.Add(mask.Lsh(mask, 1), one)
		}

		addr, _ := netip.AddrFromSlice(ipsInt.FillBytes(buf))
		cidr = append(cidr, addr.String()+"/"+bits.Sub(maxBit, bits).String())

		if nextIp.Or(ipsInt, mask); nextIp.Cmp(ipeInt) >= 0 {
			break
		}
		ipsInt.Add(nextIp, one)
	}
	return cidr, nil
}

fails for testcase fmt.Println(iPv4RangeToCIDRRange("0.0.0.0", "255.255.255.255"))

hardcoded

func IpRangeToCIDR(start, end string) ([]string, error) {
if ipStart == "0.0.0.0" && ipEnd == "255.255.255.255" {
cidrs = append(cidrs, "0.0.0.0/0") //edge case failure handle, 2^32 overflows in uint32 to 0 so hardcoded here
return cidrs, nil
}
//..... rest of the code