Comment tester si des ports sont ouverts en PowerShell

J’ai récemment eu besoin d’effectuer en volume des tests de ports pour vérifier si ces derniers étaient ouverts ou non au sein d’une infrastructure.

Jusqu’à présent, j’avais toujours résolu ce type de questions en effectuant mes tests Telnet à la main en installant sur mon Windows Server le client Telnet. Mais cela peut vite devenir un peu ennuyeux lorsque vous devez tester un grand nombre de ports (et sur plusieurs serveurs).

Contexte

Je vous propose de partager un court script PowerShell qui m’a permis de répondre à ce besoin et que j’utilise régulièrement depuis.

Mon contexte est le suivant : je dispose de plusieurs scénarios qui comportent chacun une série spécifique de ports à tester. Je souhaite donc exécuter un scénario en particulier en fonction du serveur sur lequel je suis connecté. Idéalement, je ne souhaite pas modifier le script si jamais un port doit être changé/supprimé ou ajouté.

Mon script sera composé de 2 fichiers : 1 fichier CSV qui contiendra les différents scénarios de tests et 1 script PowerShell que je pourrais appeler en fonction de mon besoin et qui utilisera en entrée le fichier CSV. Je souhaite également pouvoir tester des ports dont le protocole sera TCP ou UDP (et le script doit pouvoir gérer ça tout seul). Pas besoin de gérer d’autres protocoles dans mon cas de figure.

Comme d’habitude, je vous partage tous les fichiers à la fin de l’article pour que vous puissiez tester de votre côté si besoin. Libre à vous de copier/adapter le tout en fonction de vos besoins.

Fichier CSV

De mon côté, je suis parti sur un fichier CSV avec le contenu suivant – TestPortsOpened.csv :

view source
print?
1
scenario,name,port,protocol
2
scenario1,http,80,TCP
3
scenario1,proxy,8080,TCP
4
scenario1,https web,443,TCP
5
scenario2,ssh,22,TCP
6
scenario2,ssh_2222,2222,TCP
7
scenario2,rdp,3389,TCP
8
scenario2,udp_161,161,UDP
9
scenario2,udp_162,162,UDP

Donc avec cet exemple si je choisi d’exécuter le test correspondant au scénario 1, le script va tester les ports 80/TCP, 8080/TCP, 443/TCP.

Si je test le scénario 2, les ports testés seront les suivants 22/TCP, 2222/TCP,  3389/TCP, 161/UDP, 162/UDP.

Script PowerShell

La première partie du script TestPortsOpened.csv commencera avec les éléments suivants :

view source
print?
1
############################################################
2
# Objective: Check port requirements automatically
3
############################################################
4
param(
5
[Parameter(Mandatory=$true)]
6
[string]$scenario,
7
[Parameter(Mandatory=$true)]
8
[string]$target
9
)
10
 
11
# Variables
12
$MyFolder = (Get-Location).Path
13
$ConfigFile = $MyFolder + "\" + ($MyInvocation.MyCommand).Name.Replace(".ps1", ".csv")
14
 
15
# We read the configuration of the XML variable for the test to process
16
$data = Import-Csv $ConfigFile
17
$data = $data | Where-Object { $_.scenario -eq $scenario }

Ce script fonctionnera avec 2 paramètres : le nom du scénario à tester ainsi que l’adresse cible que l’on souhaite tester.

Les premières variables vont nous permettre successivement récupérer le dossier d’exécution du script, trouver automatiquement le fichier CSV correspondant dans le dossier et finalement notre variable $data importera notre fichier CSV pour ne garder que le scénario et les ports correspondants à tester.

view source
print?
1
foreach ($item in $data)
2
{
3
# Limit the outputs when the connection will fail
4
$ErrorActionPreference = 'SilentlyContinue'
5
 
6
# Force clearing the variable
7
$connect = $null
8
 
9
# Protocol UDP
10
if ($item.protocol -eq "UDP")
11
{
12
$connection = New-Object -TypeName System.Net.Sockets.UdpClient -ArgumentList $target,$($item.port)
13
}
14
 
15
# Protocol TCP (all others cases)
16
else
17
{
18
$connection = New-Object -TypeName System.Net.Sockets.TcpClient -ArgumentList $target,$($item.port)
19
}
20
 
21
# If connection has been successfully established
22
if ($connection.Connected)
23
{
24
# Displaying the result
25
Write-Host "Test executed on $($item.port) ($($item.protocol)) from localhost to $($target): " -NoNewline
26
Write-Host "SUCCESS" -ForegroundColor Green
27
}
28
 
29
# If the connection has timedout and can't be established
30
else
31
{
32
# Displaying the result
33
Write-Host "Test executed on $($item.port) ($($item.protocol)) from localhost to $($target): " -NoNewline
34
Write-Host "FAILED" -ForegroundColor Red
35
}
36
# Closing connection
37
$connection.Close()
38
}

Pour chaque scénario, nous avons donc plusieurs ports à tester. Dans la variable $data nous avons récupéré la liste des ports à tester pour un scénario donné.

Pour chaque ligne, nous avons donc 1 port à tester avec le numéro, un nom/description (dont nous ne faisons rien) et le protocole.

Cette boucle foreach va nous permettre pour un port donné de :

• Tester s’il s’agit d’un port UDP ou TCP et en fonction du protocole on établit une nouvelle connexion de type System.Net.Sockets.UdpClient dans le cas d’un port UDP ou System.Net.Sockets.TcpClient pour le protocole TCP ;
• Si nous parvenons à établir la connexion avec succès dans ce cas nous affichons un message de succès avec une coloration verte et la mention « SUCCESS » ;
• En revanche, sinon nous ne parvenons pas à établir la connexion dans ce cas le message se terminera de la mention « FAILED » en rouge ;
• Une fois terminé, on clos la connexion proprement. 🙂

Exemples d’exécution

Bien entendu, pour pouvoir effectuer un test probant, réalisez votre test sur un serveur ou quelque-chose dont vous maîtrisez la configuration réseau.

Pour télécharger l’intégralité du script ainsi qu’un exemple de fichier CSV suivez ce lien: TestPortsOpened. 

Testé sous Windows Server 2012 R2, 2016 (avec les versions PowerShell intégrées par défaut à ces versions d’OS).