Tester les ports réseau plus rapidement avec PowerShell

Très basique (délai d'attente 100 ms):

function testport ($hostname='yahoo.com',$port=80,$timeout=100) {
  $requestCallback = $state = $null
  $client = New-Object System.Net.Sockets.TcpClient
  $beginConnect = $client.BeginConnect($hostname,$port,$requestCallback,$state)
  Start-Sleep -milli $timeOut
  if ($client.Connected) { $open = $true } else { $open = $false }
  $client.Close()
  [pscustomobject]@{hostname=$hostname;port=$port;open=$open}
}

testport

hostname  port  open
--------  ----  ----
yahoo.com   80  True

Vous pouvez utiliser cela pour tester la connexion - Extrait du dépôt de code PowerShell (auteur 'BSonPosh'):

"Test-Port crée une connexion TCP au port spécifié. Par défaut, il se connecte au port 135 avec un délai d'attente de 3 secondes."

Param([string]$srv,$port=135,$timeout=3000,[switch]$verbose)

# Test-Port.ps1
# Effectue une connexion TCP sur le port spécifié (135 par défaut)

$ErrorActionPreference = "SilentlyContinue"

# Créer un client TCP
$tcpclient = new-Object system.Net.Sockets.TcpClient

# Indiquer au client TCP de se connecter à la machine sur le port
$iar = $tcpclient.BeginConnect($srv,$port,$null,$null)

# Définir le temps d'attente
$wait = $iar.AsyncWaitHandle.WaitOne($timeout,$false)

# Vérifier si la connexion est terminée
if(!$wait)
{
    # Fermer la connexion et signaler le dépassement du délai
    $tcpclient.Close()
    if($verbose){Write-Host "Délai de connexion dépassé"}
    Return $false
}
else
{
    # Fermer la connexion et signaler l'erreur s'il y en a une
    $error.Clear()
    $tcpclient.EndConnect($iar) | out-Null
    if(!$?){if($verbose){write-host $error[0]};$failed = $true}
    $tcpclient.Close()
}

# Retourner $true si la connexion est établie sinon $false
if($failed){return $false}else{return $true}

Vous pouvez consulter cette page du dépôt pour les suivis (cette réponse est déjà trop un copier-coller)

Une façon encore plus rapide pourrait être :

param($ip,$port)
New-Object System.Net.Sockets.TCPClient -ArgumentList $ip, $port

Le résultat serait :

Client              : System.Net.Sockets.Socket
Available           : 0
Connected           : True
ExclusiveAddressUse : False
ReceiveBufferSize   : 65536
SendBufferSize      : 65536
ReceiveTimeout      : 0
SendTimeout         : 0
LingerState         : System.Net.Sockets.LingerOption
NoDelay             : False

La valeur intéressante est "Connected"

edit : une raison de plus : Test-NetConnection ne fonctionne que depuis Powershell v5 (si je me souviens bien), alors que cette solution fonctionne depuis v2 :)

En prenant la réponse de @Jan, je l'ai rendue moins encombrée et maintenant elle fonctionne pour moi dans les tâches lancées.
C'est bien de jeter des exceptions et de ne pas compter sur $error / les utilisateurs d'API utilisant des choses non-standard "verbeuses" aussi (obtenir .Connected semble provoquer l'apparition de SocketException ce qui est propre).

        Function TestTCP { Param($address, $port, $timeout=2000)
            $socket=New-Object System.Net.Sockets.TcpClient
            try {
                $result=$socket.BeginConnect($address, $port, $NULL, $NULL)
                if (!$result.AsyncWaitHandle.WaitOne($timeout, $False)) {
                    throw [System.Exception]::new('Délai de connexion dépassé')
                }
                $socket.EndConnect($result) | Out-Null
                $socket.Connected
            }
            finally {
                $socket.Close()
            }
        }

Voici mon entrée, merci pour le code qui m'a lancé. Tout le code est documenté en ligne

PS> aide Test-PortScan -exemples

function Test-PortScan
{
<#
    .SYNOPSIS
        Teste pour voir si un port ou une plage est ouverte

    .DESCRIPTION
        Une description détaillée de la fonction Test-PortScan.

    .PARAMETER Devices
        IP ou nom d'hôte des appareils à tester. Il prendra la valeur de la pipeline afin de pouvoir tester plusieurs appareils en même temps.

    .PARAMETER StartPort
        Numéro de port de départ à tester. Par défaut, il est défini sur 1.

    .PARAMETER EndPort
        Dernier port d'une plage à balayer. Par défaut, il est le même que le port de départ, donc si vous voulez entrer seulement 1 port, vous n'avez pas à définir cette variable.

    .PARAMETER Timeout
        Durée du délai pour tester la connexion en millisecondes. Par défaut, il est de 100 millisecondes.

    .EXAMPLE
        Test-PortScan -devices 192.168.1.1 -StartPort 20 -EndPort 82
        Teste l'appareil à 192.168.1.1 sur les ports 20 - 82

    .EXAMPLE
        Test-PortScan -Devices 192.168.1.1 -StartPort 80
            Teste l'appareil à 192.168.1.1 pour le port 80 (également Test-PortScan 192.168.1.1 80)

    .EXAMPLE
        '192.168.1.1','192.168.1.2','122.168.1.3' | % {Test-PortScan -Devices $_ StartPort 22 25}
        Teste chacune de ces adresses IP sur les ports 22 - 25

    .NOTES
        # Code original trouvé ici : https://superuser.com/questions/805621/test-network-ports-faster-with-powershell
    #>

    [CmdletBinding()]
    param
    (
        [Parameter(Mandatory = $true,
                   ValueFromPipeline = $true,
                   ValueFromPipelineByPropertyName = $true,
                   Position = 0,
                   HelpMessage = 'Vous devez fournir au moins un nom de périphérique ou une IP')]
        [Alias('Nom')]
        [string]$Devices,
        [Parameter(Position = 1)]
        [int]$StartPort = 1,
        [Parameter(Position = 2)]
        [int]$EndPort = $StartPort,
        [Parameter(Position = 3)]
        [int]$Timeout = 100
    )

    BEGIN
    {
        $PSObject = @()
        $Output = @()
    }
    PROCESS
    {
        foreach ($Device in $Devices)
        {
            Write-Verbose "Pas encore dans la boucle port"
            $Port = $StartPort
            do
            {
                #($Port = $StartPort; $Port -gt $EndPort; $Port++)              
                Write-Verbose "Arrivé à la boucle de port"
                $requestCallback = $state = $null
                $client = New-Object System.Net.Sockets.TcpClient
                $beginConnect = $client.BeginConnect($Device, $Port, $requestCallback, $state)
                Start-Sleep -Milliseconds $Timeout
                if ($client.Connected) { $Open = $true }
                else { $Open = $false }
                $client.Close()
                [pscustomobject]@{
                    'Ordinateur' = $Device
                    'Port'     = $Port
                    'Ouvert'     = $Open
                }
                $Port += 1
            }
            until ($Port -gt $EndPort)
        }

    }
    END
    {

    }
}