Enhanced CIDR Block Calculator with Expanded Input Formats in Go

Efficient management of IP address ranges is critical in network engineering, cloud infrastructure, and cybersecurity. CIDR (Classless Inter-Domain Routing) blocks provide a compact way to represent IP address ranges but handling them manually can be cumbersome. Enter the CIDR-Converter, a Go-based utility designed to simplify this process while supporting expanded input formats.

Check out my repo here:

pat-glitch / cidr-converter

A CIDR block-converter

CIDR Convert

A command-line utility written in Go that processes, validates, and merges IP address ranges in various formats. The tool supports CIDR notation, wildcard notation, and multiple input/output formats.

Features

Input Processing

• Multiple input formats supported:
  • CIDR notation (e.g., "192.168.1.0/24")
  • Wildcard notation (e.g., "192.168.1.*")
  • CSV files containing CIDR blocks
  • JSON files containing CIDR blocks
• Interactive stdin mode for manual input

CIDR Operations

• Validates IP ranges and CIDR blocks
• Converts wildcard notation to CIDR format
• Merges overlapping CIDR blocks
• Sorts CIDR blocks for optimal organization

Output Handling

• Automatically saves merged results to JSON file
• Pretty-printed JSON output
• Comprehensive error handling and reporting

Installation

Ensure you have Go installed on your system, then:

git clone [repository-url]
cd [repository-name]
go build

Usage

The tool supports three input modes:

1. Standard Input Mode

./cidr-processor
# Enter CIDR blocks interactively, one per line:
192.168.1.0/24
10.0.0.*
# Press Ctrl+D (Linux/Mac) or Ctrl+Z (Windows) to

…

View on GitHub

I'm also planning to create a web-app with additional features, to increase functionality and scope of the application!

This project was inspired by Andy Walker's cidr-convert repository.

Key Features

1. Flexible Input Formats

• Supports traditional CIDR notation (e.g., 192.168.0.0/24)
• Parses wildcard notations (e.g., 192.168..)
• Converts binary strings into CIDR blocks (e.g., 11000000101010000000000000000000/24)
• Reads CIDRs from CSV and JSON files

2. Intelligent Merging

• Merges overlapping CIDRs into a minimal set, reducing redundancy
• Aggregates smaller subnets into larger ones where feasible

3. File I/O Support

• Parses input from files or standard input
• Saves merged CIDRs to a JSON file for easy sharing and storage

The Problem It Solves

Handling large lists of CIDRs can be tedious, especially when dealing with overlapping or adjacent ranges. Manually aggregating these ranges is error-prone and time-consuming. This tool automates the process, ensuring optimal aggregation and reducing the risk of mismanagement.

How It Works

Core Functionalities

1. CIDR Parsing and Validation

The parseCIDR function ensures input conforms to valid CIDR notation.

2. Wildcard and Binary Parsing

• Wildcards (e.g., 192.168..) are converted into CIDRs by analyzing the mask length
• Binary strings (e.g., 11000000101010000000000000000000/24) are translated into IP addresses

3. CIDR Merging

• The mergeCIDRs function removes redundancy by merging overlapping ranges
• The aggregateCIDRs function combines smaller subnets into larger, encompassing blocks

4. File Parsing

Reads CIDRs from CSV and JSON formats using parseCSV and parseJSON functions.

5. Output

The merged CIDRs are saved to a JSON file for easy consumption by other tools or teams.

Example Usage

Command-Line Execution

Run the tool directly from the terminal, specifying input type:

# Standard input
$ go run main.go
Enter CIDR blocks, one per line. Press Ctrl+D (Linux/Mac) or Ctrl+Z (Windows) to end input:
192.168.0.0/24
192.168.1.0/24

# CSV Input
$ go run main.go input.csv

# JSON Input
$ go run main.go input.json

Sample Output

Given the input:

192.168.0.0/24
192.168.1.0/24

The tool outputs a single aggregated block:

[
  "192.168.0.0/23"
]

Saved to merged_cidrs.json.

Code Walkthrough

Parsing Wildcard Notation

Wildcards like 192.168.. are converted into CIDRs:

func parseWildcard(input string) ([]*net.IPNet, error) {
    wildcardRegex := regexp.MustCompile(`^((?:\d{1,3}|\*)\.){3}(?:\d{1,3}|\*)$`)
    ...
}

The function calculates the appropriate prefix length and constructs a CIDR block.

Merging and Aggregation

The mergeCIDRs function eliminates redundancy:

func mergeCIDRs(cidrs []*net.IPNet) []*net.IPNet {
    sort.Slice(cidrs, func(i, j int) bool {
        return bytes.Compare(cidrs[i].IP, cidrs[j].IP) < 0
    })
    ...
}

Aggregation follows with:

func aggregateCIDRs(cidrs []*net.IPNet) []*net.IPNet {
    ...
}

This step combines adjacent ranges into larger blocks.

File Parsing

CSV and JSON input files are parsed with parseCSV and parseJSON, enabling seamless integration with existing workflows:

func parseCSV(filename string) ([]*net.IPNet, error) {
    ...
}

Why Go?

Go's robust standard library, including packages like net, regexp, and encoding/json, makes it an excellent choice for building network-related tools. Its strong concurrency model ensures high performance, even with large datasets.

Future Enhancements

1. IPv6 Support

• Extend functionality to handle IPv6 ranges

2. Dynamic Input Formats

• Add support for YAML and XML

3. Web Interface

• Build a lightweight web application for interactive CIDR management

Conclusion

The Enhanced CIDR Block Calculator simplifies CIDR management with expanded input formats, intelligent merging, and robust file support. Its versatility makes it a valuable tool for network engineers, cloud architects, and cybersecurity professionals. Inspired by Andy Walker's cidr-convert, this tool builds upon foundational ideas to offer a more comprehensive solution. Give it a try and streamline your CIDR workflows today!