Building a list of IP addresses

Question

I am trying to build an array of possible IP addresses based on a user's input. i.e. IP address along with a CIDR number. My end goal is to compare this list with a separate list of addresses and find which are is missing.

Example user input: 192.168.1.0 /24 I want to build an array for all possible values for the /24 network (i.e. the IP address can be anywhere from 192.168.1.0 - 192.168.1.255)

In order for this to work, I think I have to convert the IP address to binary and then find the bits that will be the host part of the network, which I've done here:


function ConvertToBinary{
    param($ipAddress)
   
    [string]$binaryIP = -join ($ipAddress.Split('.') | ForEach-Object {[System.Convert]::ToString($_,2).PadLeft(8,'0')})

    return $binaryIP
}

function FindHost{
    param(
        [string]$binaryIPAddress,
        [int32]$CIDR
    )
    $hostBits = 32-$CIDR
    [string]$myHost = $binaryIPAddress.Substring($binaryIPAddress.Length-$hostBits)

    return $myHost
}


$myip = ConvertToBinary "192.168.3.1"
$myHost = FindHost  $myip 8

I'm a little stuck on how to proceed, so if anyone can help me out or point me in the right direction, it would be much appreciated

user_7411885 · Answer

I wrote this using some similar questions to get the first and last address for any subnet given a random IP and mask:

Function Get-SubnetAddresses {
Param ([IPAddress]$IP,[ValidateRange(0, 32)][int]$maskbits)

  # Convert the mask to type [IPAddress]:
  $mask = ([Math]::Pow(2, $MaskBits) - 1) * [Math]::Pow(2, (32 - $MaskBits))
  $maskbytes = [BitConverter]::GetBytes([UInt32] $mask)
  $DottedMask = [IPAddress]((3..0 | ForEach-Object { [String] $maskbytes[$_] }) -join '.')
  
  # bitwise AND them together, and you've got the subnet ID
  $lower = [IPAddress] ( $ip.Address -band $DottedMask.Address )

  # We can do a similar operation for the broadcast address
  # subnet mask bytes need to be inverted and reversed before adding
  $LowerBytes = [BitConverter]::GetBytes([UInt32] $lower.Address)
  [IPAddress]$upper = (0..3 | %{$LowerBytes[$_] + ($maskbytes[(3-$_)] -bxor 255)}) -join '.'

  # Make an object for use elsewhere
  Return [pscustomobject][ordered]@{
    Lower=$lower
    Upper=$upper
  }
}

Usage looks like:

Get-IPAddresses 10.43.120.8 22

Lower       Upper        
-----       -----        
10.43.120.0 10.43.123.255

And I put this together to generate the whole list. I'm sure this could be done better, but the simple instructions run fast enough:

Function Get-IPRange {
param (
  [Parameter(Mandatory=$true,ValueFromPipelineByPropertyName)][IPAddress]$lower,
  [Parameter(Mandatory=$true,ValueFromPipelineByPropertyName)][IPAddress]$upper
)
  # use lists for speed
  $IPList = [Collections.ArrayList]::new()
  $null = $IPList.Add($lower)
  $i = $lower

  # increment ip until reaching $upper in range
  while ( $i -ne $upper ) { 
    # IP octet values are built back-to-front, so reverse the octet order
    $iBytes = [BitConverter]::GetBytes([UInt32] $i.Address)
    [Array]::Reverse($iBytes)

    # Then we can +1 the int value and reverse again
    $nextBytes = [BitConverter]::GetBytes([UInt32]([bitconverter]::ToUInt32($iBytes,0) +1))
    [Array]::Reverse($nextBytes)

    # Convert to IP and add to list
    $i = [IPAddress]$nextBytes
    $null = $IPList.Add($i)
  }

  return $IPList
}

Converting to [IPAddress] on the last line is nice for validating all the results are real, but probably not necessary if you just want the ipv4 strings. Usage:

Get-SubnetAddresses 10.43.120.8 30 | Get-IPRange | Select -ExpandProperty IPAddressToString
10.43.120.8
10.43.120.9
10.43.120.10
10.43.120.11

Sources:

Building a list of IP addresses

1 Answers