My focus on networking in the IT industry has shown to me that a lot of (but certainly not all) network engineers lack scripting and automation skills, especially when it comes to manipulation and documentation of IP addresses, as well as their underlying representation in memory. I’ve observed Excel spreadsheets where the IPs were simply represented as text. Or ones where an IPv4 address was simply divided into a separate column for each octet and otherwise treated as set of unrelated integers mashed across four separate columns. Even if it’s inside a script, typically using a dynamically typed language, they are most often just stored as a string.

This, I believe, is entirely the wrong approach to store them. In memory, they are stored as an array of bytes. So why shouldn’t they just be handled as byte arrays in your script?

The one important piece of information, if you plan to do this, is the byte order in memory (on most modern architectures) is little endian. However, network byte order (aka big endian) is how bytes are ordered for use in various network protocols. Let’s look at the difference, given the IP 10.20.30.75:

Little endian for 10.20.30.75: 01001011.00011110.00010100.00001010

Network byte order for 10.20.30.75: 00001010.00010100.00011110.01001011

Notice the difference for each of these byte-ordering schemes is the reverse of the other.

Knowing this, it’s time to see if we can store an IP address in a reasonable way inside a scripting language. For this, I will be using PowerShell, which provides great support via the System.Net.IPAddress class. A simple way to instantiate one is as follows:

$ip = [IPAddress] "10.20.30.75"

However, in order to display the System.Net.IPAddress as a string, we can use the ToString() method:

PS C:\windows\system32> $ip = [IPAddress] "10.20.30.75"
PS C:\windows\system32> $ip.ToString()
10.20.30.75

Interestingly, if we try to get the value of Address property of a System.Net.IPAddress, we find it’s returning an integer:

PS C:\windows\system32> $ip.Address
1260262410
PS C:\windows\system32> $ip.Address.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Int64                                    System.ValueType

An interesting point is that if we want to cast an integer to a System.Net.IPAddress, it needs to be a 32-bit signed integer (UInt32) instead of a 64-bit signed integer (Int64).

So, how is this useful? If we combine the IP address with a subnet mask, we can calculate a whole bunch of useful addresses. First, the subnet mask will be stored as another System.Net.IPAddress:

PS C:\windows\system32> $subnetMask = [IPAddress] "255.255.255.224"

Next, we can calculate the network address by performing a binary AND operation on the IP and the subnet mask.

PS C:\windows\system32> [IPAddress]$networkAddress = $ip.Address -band $subnetMask.Address
PS C:\windows\system32> $networkAddress.ToString()
10.20.30.64

Another useful address to know would be the broadcast address of the network we’re describing. This can be calculated by first calculating a wildcard address by performing a binary NOT of the subnet mask and then performing a binary OR operation against the network address and wildcard address:

PS C:\windows\system32> [IPAddress]$wildCardAddress = -bnot [UInt32]$subnetMask.Address
PS C:\windows\system32> [IPAddress]$broadcastAddress = $networkAddress.Address -bor $wildCardAddress.Address
PS C:\windows\system32> $wildCardAddress.ToString()
0.0.0.31
PS C:\windows\system32> $broadcastAddress.ToString()
10.20.30.95

Finally, as you know, a gateway can be any valid host address on the network. Usually it’s one up from the network address or one down from the broadcast address. Here’s two quick options to do either:

PS C:\windows\system32> [IPAddress]$gatewayAddressOptionOne = $networkAddress.Address + ([IPAddress] "0.0.0.1").Address
PS C:\windows\system32> [IPAddress]$gatewayAddressOptionTwo = $broadcastAddress.Address - ([IPAddress] "0.0.0.1").Address
PS C:\windows\system32> $gatewayAddressOptionOne.ToString()
10.20.30.65
PS C:\windows\system32> $gatewayAddressOptionTwo.ToString()
10.20.30.94

Finally, I will leave you some functions for easily display a System.Net.IPAddress object as string of binary digits nicely formatted with a delimiter between each octet (as your have already seen in this article):

function ByteToBinaryString {
    param (
        [Byte] $byte
    )
    return [Convert]::toString($byte,2)
}


function IpAddresstoBinary {
    param (
        [IPAddress] $ipAddress
    )
    [Byte[]] $bytes = $ipAddress.GetAddressBytes()

    # Convert from little endian to network byte order...
    [Array]::Reverse($bytes)

    [String] $return = $null
    [Bool] $firstPass = $true
    ForEach ($byte in $bytes) {
        $binaryAsString = ByteToBinaryString($byte)
        For ($i = $binaryAsString.length; $i -lt 8; $i++) {
            $binaryAsString = '0' + $binaryAsString
        }
        if (!$firstpass) {
            $return = '.' + $return
        }
        $return = $binaryAsString + $return
        $firstPass = $false
    }
    return $return
}