Get-Network.ps1

<#
.SYNOPSIS
Displays network adapter information and optionally WiFi profiles with clear text passphrases.
Can be used to determine the most likely candidate for the active Internet-specific network
adapter. Only connected IP adapters are considered; all other adpaters such as tunneling and
loopbacks are ignored.

.PARAMETER Addresses
Return a @(list) of addresses

.PARAMETER bound
Show only interfaces that are bound to a known IP address, hiding disconnected virtual
or VPN interfaces.

.PARAMETER Preferred
Only return the preferred network address without report bells and whistles.

.PARAMETER Verbose
Display extra information including MAC addres and bytes sent/received.

.PARAMETER WiFi
Show detailed WiFi profiles include clear text passwords, highlighting
currently active SSID and open networks.
#>

using namespace System.Net
using namespace System.Net.NetworkInformation

[CmdletBinding()]

param(
	[switch] $preferred,	# just return the preferred address
	[switch] $addresses,	# return a list of host addresses
	[switch] $bound,        # show only interfaces bound to an IP address
	[switch] $wiFi			# show detailed WiFi profiles
)

Begin
{
	$esc = [char]27

	function GetAllAddresses
	{
		$addresses = @()
		if ([Net.NetworkInformation.NetworkInterface]::GetIsNetworkAvailable())
		{
			[Net.NetworkInformation.NetworkInterface]::GetAllNetworkInterfaces() | foreach `
			{
				$props = $_.GetIPProperties()

				$address = $props.UnicastAddresses `
					| where { $_.Address.AddressFamily -eq 'InterNetwork' } `
					| select -first 1 -ExpandProperty Address

				if ($address)
				{
					$addresses += $address.IPAddressToString
				}
			}
		}

		$addresses
	}

	function GetPreferredAddress
	{
		$prefs = @()
		if ([Net.NetworkInformation.NetworkInterface]::GetIsNetworkAvailable())
		{
			[Net.NetworkInformation.NetworkInterface]::GetAllNetworkInterfaces() | foreach `
			{
				if (($_.NetworkInterfaceType -ne 'Loopback') -and ($_.OperationalStatus -eq 'Up'))
				{
					$props = $_.GetIPProperties()
 
					$address = $props.UnicastAddresses `
						| where { $_.Address.AddressFamily -eq 'InterNetwork' } `
						| select -first 1 -ExpandProperty Address

					$DNSServer = $props.DnsAddresses `
						| where { $_.AddressFamily -eq 'InterNetwork' } `
						| select -first 1 -ExpandProperty IPAddressToString

					if ($address -and $DNSServer)
					{
						$prefs += $address.IPAddressToString
					}
				}
			}
		}

		if ($prefs.Length -gt 0)
		{
			return $prefs[0]
		}

		return $null
	}

	function CollectInformation
	{
		$preferred = $null
		$items = @()
		if ([Net.NetworkInformation.NetworkInterface]::GetIsNetworkAvailable())
		{
			$SSID = $null
			(netsh wlan show interfaces | select-string '\sSSID') -match '\s{2,}:\s(.*)' | Out-Null
			if ($Matches -and $Matches.Count -gt 1)
			{
				$SSID = $Matches[1].ToString()
			}

			[Net.NetworkInformation.NetworkInterface]::GetAllNetworkInterfaces() | foreach `
			{
				if ($_.NetworkInterfaceType -ne 'Loopback')
				{
					$item = New-Object PSObject -Property @{
						Address         = $null
						PhysicalAddress = $_.GetPhysicalAddress().ToString()
						DNSServer       = $null
						Gateway         = $null
						Description     = $null
						DnsSuffix       = $null
						SSID            = $null
						BytesReceived   = 0
						BytesSent       = 0
						Status          = $_.OperationalStatus
						Type            = $_.NetworkInterfaceType
					}

					$props = $_.GetIPProperties()

					$item.Address = $props.UnicastAddresses `
						| where { $_.Address.AddressFamily -eq 'InterNetwork' } `
						| select -first 1 -ExpandProperty Address

					if ($item.Address -or -not $bound)
					{
						$item.DNSServer = $props.DnsAddresses `
							| where { $_.AddressFamily -eq 'InterNetwork' } `
							| select -first 1 -ExpandProperty IPAddressToString

						$item.Gateway = $props.GatewayAddresses `
							| where { $_.Address.AddressFamily -eq 'InterNetwork' } `
							| select -first 1 -ExpandProperty Address

						$stats = $_.GetIPv4Statistics() | Select -first 1
						$item.BytesReceived = $stats.BytesReceived
						$item.BytesSent = $stats.BytesSent

						$item.Description = $_.Name + ', ' + $_.Description
						$item.DnsSuffix = $props.DnsSuffix
						if (![String]::IsNullOrWhiteSpace($item.DnsSuffix))
						{
							$item.Description += (', ' + $item.DnsSuffix)
						}

						if ($item.Type.ToString().StartsWith('Wireless') -and $SSID -and ($item.BytesReceived -gt 0))
						{
							$item.Description = (', ' + $SSID)
						}

						if (($item.Status -eq 'Up') -and $item.Address -and ($item.BytesReceived -gt 0))
						{
							if (!$preferred)
							{
								$preferred = $item
							}

							if (!$preffered.SSID)
							{
								$preferred.SSID = $SSID
							}
						}

						$items += $item
					}
				}
			}
		}

		@{
			Preferred = $preferred
			Items = $items
		}
	}

	function ShowPreferred
	{
		param($preferred)
		Write-Host
		if ($preferred -eq $null)
		{
			Write-Host ('{0} Preferred address is unknown' -f $env:COMPUTERNAME) -ForegroundColor DarkGreen -NoNewline
		}
		else
		{
			Write-Host ("{0} Preferred address is {1}" -f $env:COMPUTERNAME, $preferred.Address) -ForegroundColor Green -NoNewline
		}

		if ($preferred.SSID)
		{
			Write-Host " | SSID:$($preferred.SSID)" -ForegroundColor DarkGreen -NoNewline
		}

		# make FQDN
		$domain = [IPGlobalProperties]::GetIPGlobalProperties().DomainName
		if ([String]::IsNullOrEmpty($domain)) { $domain = [Dns]::GetHostName() }
		$name = [Dns]::GetHostName()
		if ($name -ne $domain) { $name = $name + '.' + $domain }
		Write-Host " | HOST:$name" -ForegroundColor DarkGreen
	}

	function GetColorOf
	{
		param($item, $preferred)
		if ($item.Status -ne 'Up') { @{ foregroundcolor='DarkGray' } }
		elseif ($item.Address -eq $preferred.Address) { @{ foregroundcolor='Green' } }
		elseif ($item.Type -match 'Wireless') { @{ foregroundcolor='Cyan' } }
		elseif ($item.Description -match 'Bluetooth') { @{ foregroundcolor='DarkCyan' } }
		else { @{ } }
	}

	function ShowBasicInfo
	{
		param($info)
		Write-Host
		Write-Host 'Address         DNS Server      Gateway         Interface'
		Write-Host '-------         ----------      -------         ---------'
		$info.Items | foreach `
		{
			$line = ("{0,-15} {1,-15} {2,-15} {3}" -f $_.Address, $_.DNSServer, $_.Gateway, $_.Description)
			$hash = GetColorOf $_ $info.Preferred
			Write-Host $line @hash
		}
	}

	function ShowDetailedInfo
	{
		param($info)
		Write-Host
		Write-Host 'IP/DNS/Gateway   Interface Details'
		Write-Host '--------------   -----------------'
		$info.Items | foreach `
		{
			if ($_.PhysicalAddress) {
				for ($i = 10; $i -gt 0; $i -= 2) { $_.PhysicalAddress = $_.PhysicalAddress.insert($i, '-') }
			}

			$hash = GetColorOf $_ $info.Preferred

			Write-Host ("{0,-15}  {1}" -f $_.Address, $_.Description) @hash
			Write-Host ("{0,-15}  Physical Address.. {1}" -f $_.DNSServer, $_.PhysicalAddress) -ForegroundColor DarkGray
			Write-Host ("{0,-15}  Type.............. {1}" -f $_.Gateway, $_.Type) -ForegroundColor DarkGray

			if ($_.Status -eq 'Up')
			{
				Write-Host ("{0,16} Bytes Sent........ {1:N0}" -f '',$_.BytesSent) -ForegroundColor DarkGray
				Write-Host ("{0,16} Bytes Received.... {1:N0}" -f '',$_.BytesReceived) -ForegroundColor DarkGray

				if ($_.DnsSuffix)
				{
					Write-Host ("{0,16} DnsSuffix......... {1}" -f '',$_.DnsSuffix) -ForegroundColor DarkGray
				}
			}

			Write-Host
		}
	}

	function ShowWiFiProfiles
	{
		Write-Host
		Write-Host '... fetching WiFi profiles' -ForegroundColor DarkGray -NoNewline

		$path = Join-Path $env:temp 'wxpx'
		if (Test-Path $path)
		{
			Remove-Item $path\*.xml -Force -Confirm:$false
		}
		else
		{
			New-Item -ItemType Directory $path -Force | Out-Null
		}

		netsh wlan export profile folder=$path key=clear | Out-Null

		$profiles = @()
		Get-Item $path\Wi-Fi-*.xml | foreach `
		{
			[xml]$xml = Get-Content $_
			$pkg = $xml.WLANProfile
			$key = $pkg.MSM.Security.sharedKey
			if ($key)
			{
				$keyType = $key.keyType
				$protected = $key.protected
				$material = $key.keyMaterial
			}
			else
			{
				$keyType = [String]::Empty
				$protected = [String]::Empty
				$material = [String]::Empty
			}

			$profiles += New-Object PSObject -Property @{
				SSID           = $pkg.SSIDConfig.SSID.name
				Mode           = $pkg.connectionMode
				Authentication = $pkg.MSM.Security.authEncryption.Authentication
				Encryption     = $pkg.MSM.Security.authEncryption.encryption
				KeyType        = $keyType
				Protected      = $protected
				Material       = $material
			}
		}

		(netsh wlan show interfaces | select-string ' SSID') -match '\s{2,}:\s(.*)' | Out-Null
		$active = $Matches[1].ToString()

		Write-Host "`n`nWi-Fi Profiles" -NoNewline -ForegroundColor Green
		Write-Host ", Active:$active" -NoNewline -ForegroundColor DarkGreen
		Write-Host " (netsh wlan delete profile name='NAME')" -ForegroundColor DarkGray

		$profiles | `
			Select-Object SSID, Mode, Authentication, Encryption, KeyType, Protected, Material | `
			Format-Table `
				@{ Label = 'SSID'; Expression = { MakeExpression $_ $_.SSID $active } }, `
				@{ Label = 'Mode'; Expression = { MakeExpression $_ $_.Mode $active } }, `
				@{ Label = 'Authentication'; Expression = { MakeExpression $_ $_.Authentication $active } }, `
				@{ Label = 'Encryption'; Expression = { MakeExpression $_ $_.Encryption $active } }, `
				@{ Label = 'KeyType'; Expression = { MakeExpression $_ $_.KeyType $active } }, `
				@{ Label = 'Protected'; Expression = { MakeExpression $_ $_.Protected $active } }, `
				@{ Label = 'Material'; Expression = { MakeExpression $_ $_.Material $active } } `
				-AutoSize

		Remove-Item $path -Force -Recurse -Confirm:$false
	}

	function MakeExpression
	{
		param($profile, $value, $active)
		if ($profile.SSID -eq $active) { $color = '92' }
		elseif ($profile.Encryption -eq 'none') { $color = '31' }
		elseif ($profile.Mode -eq 'manual') { $color = '90' }
		else { $color = '97' }

		"$esc[$color`m$($value)$esc[0m"
	}
}
Process
{
	if ($preferred)
	{
		return GetPreferredAddress
	}

	if ($addresses)
	{
		return GetAllAddresses
	}

	$script:verbose = $PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent

	$info = CollectInformation
	if ($info -and $info.Items -and $info.Items.Count -gt 0)
	{
		ShowPreferred $info.Preferred

		if ($verbose)
		{
			ShowDetailedInfo $info
		}
		else
		{
			ShowBasicInfo $info
		}
	}
	else
	{
		Write-Host 'Network unavailable' -ForegroundColor Red
	}

	if ($wiFi)
	{
		ShowWiFiProfiles
	}
}

<#
    ... This is a whole lot less code but is much slower then the code above 

$candidates = @()
Get-NetIPConfiguration | % `
{
	$dns = $_.DNSServer | ? { $_.AddressFamily -eq 2 } | select -property ServerAddresses | select -first 1
	$ifx = $_.InterfaceAlias + ', ' + $_.InterfaceDescription
	if ($_.NetProfile.Name -notmatch 'Unidentified') { $ifx += (', ' + $_.NetProfile.Name) }

	$candidates += New-Object psobject -Property @{
		Address = $_.IPv4Address.IPAddress
		DNSServer = [String]::Join(',', $dns.ServerAddresses)
		Gateway = $_.IPv4DefaultGateway.NextHop
		Interface = $ifx
	}
}
#>