Alle manieren om te controleren of een poort open is in Linux

Je Linux-server draait en je wilt nu controleren of een specifieke poort open staat zodat je er op afstand toegang toe kunt krijgen. Het controleren van open poorten is een vrij gebruikelijke taak voor systeembeheerders, en er zijn verschillende manieren om dit te doen in Linux.

In dit artikel leer je verschillende manieren om te controleren of een poort open staat in Linux, zodat je kunt kiezen welke het beste voor jou werkt. Klaar? Lees verder!

Vereisten

Deze zelfstudie zal een praktische demonstratie zijn. Als je wilt meedoen, zorg er dan voor dat je het volgende hebt.

  • A Linux computer. This guide uses Ubuntu 20.04, but any recent Linux distribution should work.
  • Toegang tot een terminal. Als je een grafische desktopomgeving gebruikt, zoek dan naar een terminal-emulatorprogramma in je toepassingsmenu. Of, als je via SSH bent ingelogd op een externe server,
  • A user account with sudo privileges. For simplicity, this tutorial uses the root user.

Controleer of een poort open staat in Linux met behulp van netstat

De eerste methode om te controleren of een poort open staat in Linux is door het uitvoeren van het netstat-commando. Dit commando geeft netwerkverbindingen, routetabellen en veel netwerkinterfacestatistieken weer.

Het netstat-commando maakt deel uit van het net-tools-pakket, en dit pakket wordt mogelijk niet standaard meegeleverd met je Linux-distributie. Op Ubuntu installeer je netstat door de volgende commando’s uit te voeren in de terminal.

apt update -y && apt install net-tools -y

Stel dat je een NGINX-webserver hebt draaien en wilt controleren of poort 80 open staat. Dit kun je doen door het volgende commando uit te voeren. Vervang 80 door het poortnummer dat je wilt controleren.

De -tulpn-vlaggen geven netstat de opdracht om alle luisterende poorten weer te geven. Het eerste grep-commando vindt en filtert de regel met het woord LISTEN in het resultaat. Het tweede grep-commando filtert de resultaten zodat alleen die items worden weergegeven die overeenkomen met :80.

netstat -tulpn | grep LISTEN | grep :80

Om meer te weten te komen over de netstat-vlaggen, voer je het commando netstat –help uit.

Als de poort open staat, zie je de volgende uitvoer. Zoals je kunt zien, toont de uitvoer dat poort 80 open staat op het systeem. tcp is het protocoltype, en :::80 geeft aan dat het een TCPv6-poort is. 0.0.0.0:80 betekent dat de poort open staat voor alle IPv4-adressen. 80 is de standaard HTTP-poort die toegang biedt tot de website.

Checking If a Port is Open with netstat

Controleren of een Poort Open staat met ss

De ss-opdracht is een andere opdrachtregelhulpprogramma om open poorten te controleren. Deze opdracht geeft socketstatistieken weer die je kunt gebruiken om te bevestigen of een poort open is of niet. De ss-opdracht toont meer informatie over open poorten dan andere tools.

Net als de netstat-opdracht geeft de -t-vlag ss de opdracht om alleen TCP-sockets weer te geven, -u om alleen UDP-sockets weer te geven, en -l om alleen luisterende sockets weer te geven. De -p-vlag geeft de procesnaam of PID aan die de poort gebruikt.

ss -tulpn | grep LISTEN | grep :80

Je ziet de volgende output als de poort open is. Zoals je kunt zien, bevat de output de procesnaam en PID voor elke luisterende poort. In dit geval is poort 80 open, en de NGINX-webserver gebruikt deze.

Checking If a Port is Open Using ss

Controleren of een poort open is met behulp van lsof

De lsof-opdracht is een ander handig hulpprogramma om open poorten te controleren. De naam lsof staat voor lijst open bestanden, die informatie weergeeft over bestanden die open zijn op het systeem. Deze informatie omvat bestandsdescriptoren, proces-IDs, gebruikers-IDs, enzovoort.

Hoe helpt het weergeven van open bestanden je bij het bepalen of een poort open is? Je hebt waarschijnlijk al gehoord van de uitdrukking “alles in Linux is een bestand,” en deze uitdrukking betekent wat het zegt.

Bijvoorbeeld, stel dat je wilt controleren of poort 22 open is en of je gebruikers via SSH op je server kunnen inloggen. Voer de onderstaande opdracht uit om open bestanden met actieve verbindingen op poort 22 weer te geven.

De -i vlag instrueert lsof om alle open Internet sockets weer te geven. De -P vlag toont de poortnummers in plaats van de servicenamen. En de -n vlag onderdrukt DNS- en servicenaamopzoekingen, zodat je de IP-adressen in plaats van de hostnamen ziet.

lsof -i -P -n | grep LISTEN | grep :22

Als de poort open is, zie je de volgende output. Zoals je kunt zien, bevat de output informatie over:

  • 1027 is het proces-id van de sshd-service.
  • root is de gebruikers-id die de poort gebruikt.
  • 3u en 4u zijn de bestandsdescriptoren voor respectievelijk IPv4 en IPv6.
  • 31035 en 31037 zijn de netwerkpoorten voor respectievelijk IPv4 en IPv6.
  • :22 geeft aan dat poort 22 open staat voor alle IPv4- en IPv6-adressen.
  • (LISTEN) geeft aan dat de poort luistert naar inkomende verbindingen.
  • 0t0 is de status van de socket, wat betekent dat de socket zich in de LISTEN-toestand bevindt.
Checking If a Port is Open Using lsof

Controleren of een Poort Open is met nmap

Tot nu toe heb je gezien hoe je kunt controleren of een poort open is op Linux via de commandoregel. Maar wat als je wilt controleren of een poort open is op een externe machine? In dat geval kun je de nmap-tool gebruiken.

Maar voordat je nmap uitvoert, wees ervan bewust dat deze tool mogelijk geen deel uitmaakt van de standaardpakketten in je Linux-distributie. In dat geval moet je eerst nmap installeren door de onderstaande opdracht uit te voeren.

apt install nmap -y

Voer nu de volgende opdracht uit om te controleren of een poort open is op een externe machine. Deze opdracht test of poort 22 open is op 159.89.176.25, zodat uw gebruiker via SSH toegang kan krijgen tot uw server. Vervang het IP-adres indien nodig door het uwe.

nmap -p 22 159.89.176.25

Zoals u kunt zien, bevat de uitvoer informatie over:

  • De starttijd van het scannen van de poorten (2022-06-30 16:58 UTC).
  • Het IP-adres van de externe machine (159.89.176.25).
  • De status van de poort (open).
  • De service die de poort gebruikt (ssh).
  • De status van de host (up).
Checking If a Port is Open Using nmap

Het resultaat bevestigt dat gebruikers via SSH toegang kunnen krijgen tot de computer met het opgegeven IP-adres en poortnummer.

ssh [email protected] -p 22

De onderstaande schermafbeelding toont een succesvolle SSH-verbinding met de server, waaruit blijkt dat poort 22 open is.

SSHing into your server

Testen of een poort open is vanuit een shell-script

Automatisering is altijd een goed idee. Het controleren van open poorten door het uitvoeren van een shell-script is een uitstekende manier om meerdere poorten te testen. U kunt eerdere methoden gebruiken om te controleren of een poort open is. Maar, voor dit voorbeeld, schrijft u een eenvoudig shell-script dat de Netcat nc-opdracht uitvoert.

1. Maak een bestand met de naam check_port.sh aan in je thuismap met behulp van je favoriete teksteditor. In dit voorbeeld wordt nano gebruikt.

nano check_port.sh

2. Kopieer de onderstaande voorbeeldcode naar je editor. Vervang 80 door het poortnummer dat je wilt controleren.

De if-voorwaarde controleert of poort 80 open is met behulp van het nc-commando. De 2>&1 en >/dev/null leiden de fout- en uitvoerberichten om naar /dev/null, respectievelijk. De /dev/null is een speciaal bestand dat alles wat het ontvangt verwerpt.

Als de poort open is, zal het script check_port.sh Online naar de console afdrukken. Anders zal het script Offline afdrukken.

if ( nc -zv localhost 80 2>&1 >/dev/null ); then
    echo 'Online'
else
    echo 'Offline'
fi

Het scriptbestand moet er ongeveer uitzien zoals op de onderstaande schermafbeelding. Sla het script op en verlaat de editor.

Creating the Shell script

3. Voer het shell-script uit om te beginnen met het controleren van de opgegeven open poorten binnen het script.

bash check_port.sh

Je ziet een van de volgende uitvoer, afhankelijk van of de poort open is. In dit geval is de poort open, wat de boodschap Online bevestigt.

Check if the 80 port is open

U kunt deze shell-script gebruiken om te controleren of een poort open is op een interval of een geplande taak. Scripting is vooral handig wanneer u meerdere servers moet controleren. U hoeft alleen maar dit check_port.sh script te kopiëren naar alle servers die u wilt controleren en het uit te voeren met behulp van CI/CD-tools zoals Jenkins of Ansible.

Het testen of een poort open is met behulp van PowerShell

PowerShell heeft een ingebouwde cmdlet voor het testen van netwerkverbindingen genaamd Test-NetConnection — maar die cmdlet is alleen beschikbaar op Windows-systemen. Maak je geen zorgen; je kunt nog steeds PowerShell in Linux gebruiken om open poorten en verbindingen te controleren met behulp van de TcpClient klasse.

Als uw Linux-computer nog geen PowerShell heeft, installeer het dan door de instructies te volgen in deze Microsoft-documentatie: PowerShell installeren op Linux.

1. Start PowerShell door de onderstaande opdracht uit te voeren.

pwsh
Launching PowerShell

2. Maak vervolgens een bestand genaamd Test-Port.ps1 met behulp van uw teksteditor. Dit voorbeeld maakt gebruik van nano.

nano Test-Port.ps1

3. Kopieer vervolgens de onderstaande code naar uw editor. Sla het bestand op en sluit daarna de editor af.

Opmerking: Deze code is een uittreksel van de Alles-in-één PowerShell Test Poort Test Tool.

<#
	.SYNOPSIS
		Deze functie test open TCP/UDP-poorten.
	.BESCHRIJVING
		Deze functie test elke TCP/UDP-poort om te zien of deze open of gesloten is.
	.NOTITIES

	.PARAMETER Computernaam
		Eén of meer externe, door komma's gescheiden computernamen.
	.PARAMETER Poort
		Eén of meer door komma's gescheiden poortnummers die u wilt testen.
	.PARAMETER TcpTimeout
		Het aantal milliseconden dat de functie zal wachten voordat deze de
		TCP-poort als gesloten verklaart. Standaard is 1000.
	.VOORBEELD
		PS> Test-Port -Computernaam 'LABDC','LABDC2' -Protocol TCP 80,443
		
		Dit voorbeeld test de TCP-netwerkpoorten 80 en 443 op zowel de LABDC-
		als de LABDC2-servers.
	#>
[CmdletBinding()]
[OutputType([System.Management.Automation.PSCustomObject])]
param (
    [Parameter(Mandatory)]
    [string[]]$ComputerName,
    [Parameter(Mandatory)]
    [int[]]$Port,
    [Parameter()]
    [int]$TcpTimeout = 1000
)
begin {
    $Protocol = 'TCP'
}
process {
    foreach ($Computer in $ComputerName) {
        foreach ($Portx in $Port) {            
            $Output = @{ 'Computername' = $Computer; 'Port' = $Portx; 'Protocol' = $Protocol; 'Result' = '' }
            Write-Verbose "$($MyInvocation.MyCommand.Name) - Beginning port test on '$Computer' on port '$Protocol<code>:$Portx'"

            $TcpClient = New-Object System.Net.Sockets.TcpClient
            $Connect = $TcpClient.BeginConnect($Computer, $Portx, $null, $null)
            $Wait = $Connect.AsyncWaitHandle.WaitOne($TcpTimeout, $false)
            if (!$Wait -or !($TcpClient.Connected)) {
                $TcpClient.Close()
                Write-Verbose "$($MyInvocation.MyCommand.Name) - '$Computer' failed port test on port '$Protocol</code>:$Portx'"
                $Output.Result = $false
            }
            else {
                $TcpClient.EndConnect($Connect)
                $TcpClient.Close()
                Write-Verbose "$($MyInvocation.MyCommand.Name) - '$Computer' passed port test on port '$Protocol<code>:$Portx'"
                $Output.Result = $true
                $TcpClient.Close()
                $TcpClient.Dispose()
            }
            [pscustomobject]$Output
        }
    }
}

4. Nadat het Test-Port.ps1-script is opgeslagen, voer de onderstaande opdracht uit om poorten 22, 80, 443 en 53 te testen.

De parameter -Computernaam accepteert een lijst met hostnamen, FQDN of IP-adressen van de doelmachine(s).

De parameter -Poort accepteert een array van één of meer poortnummers om te testen.

./Test-Port.ps1 -ComputerName localhost -Port 22,80,443

Zoals je hieronder kunt zien, toont het resultaat aan dat poorten 22 en 80 open zijn (True), terwijl poort 443 dat niet is (False).

Checking for open ports using PowerShell scripting

Om hetzelfde script uit te voeren tegen meerdere doel-eindpunten en poorten, bewerk de onderstaande code om alle doelcomputers toe te voegen aan de parameter Computernaam en de poortnummers aan de parameter Poort.

./Test-Port.ps1 `
    -ComputerName adamtheautomator.com,localhost,8.8.8.8 `
    -Port 22,80,443,53
Checking for open ports on multiple targets using PowerShell scripting

Conclusie

In dit artikel heb je geleerd hoe je kunt controleren of een poort open of gesloten is in Linux. Je hebt ook geleerd om te controleren of een poort open is vanuit een shell-script en PowerShell. Nu kun je een van deze methoden gebruiken om te controleren of een poort open is op jouw machine of op een externe machine.

Maar hier stopt het niet. Bekijk ook andere oplossen van problemen artikelen om je systeembeheervaardigheden verder te ontwikkelen!

Source:
https://adamtheautomator.com/check-if-a-port-is-open-in-linux/