Tutti i modi per verificare se una porta è aperta in Linux

Il tuo server Linux è in esecuzione e ora vuoi verificare se una porta specifica è aperta in modo da potervi accedere da remoto. Verificare le porte aperte è un compito abbastanza comune per gli amministratori di sistema e ci sono alcuni modi diversi per farlo in Linux.

In questo articolo, imparerai diversi modi per verificare se una porta è aperta in Linux in modo da poter scegliere quello che funziona meglio per te. Pronto? Continua a leggere!

Prerequisiti

Questo tutorial sarà una dimostrazione pratica. Se vuoi seguirmi, assicurati di avere quanto segue.

• A Linux computer. This guide uses Ubuntu 20.04, but any recent Linux distribution should work.

Correlato:Come Installare Ubuntu 20.04 [Passo dopo Passo]

• Accesso a un terminale. Se usi un ambiente desktop grafico, cerca un programma emulatore di terminale nel menu delle applicazioni. Oppure, se hai effettuato l’accesso a un server remoto tramite SSH,

Correlato:Un Utente Windows in un Mondo Linux: Configurazione del Comando SSH

• A user account with sudo privileges. For simplicity, this tutorial uses the root user.

Verifica se una Porta è Aperta in Linux Usando netstat

Il primo metodo per verificare se una porta è aperta in Linux consiste nell’eseguire il comando netstat. Questo comando mostra le connessioni di rete, le tabelle di routing e molte statistiche delle interfacce di rete.

Il comando netstat fa parte del pacchetto net-tools e questo pacchetto potrebbe non essere incluso di default nella tua distribuzione Linux. Su Ubuntu, installa netstat eseguendo i seguenti comandi nel terminale.

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

Correlato:Imparare Ubuntu Apt Get Attraverso Esempi

Supponiamo che tu abbia un server web NGINX in esecuzione e desideri verificare se la porta 80 è aperta. Puoi farlo eseguendo il seguente comando. Sostituisci 80 con il numero di porta che desideri verificare.

I flag -tulpn istruiscono netstat a visualizzare tutte le porte in ascolto. Il primo comando grep trova e filtra la riga contenente la parola LISTEN nel risultato. Il secondo comando grep filtra i risultati per visualizzare solo gli elementi corrispondenti a :80.

netstat -tulpn | grep LISTEN | grep :80

Correlato:Come Cercare tramite Grep con Regex

Per saperne di più sui flag di netstat, esegui il comando netstat –help.

Se la porta è aperta, vedrai il seguente output. Come puoi vedere, l’output mostra che la porta 80 è aperta sul sistema. tcp è il tipo di protocollo, e :::80 indica che è una porta TCPv6. 0.0.0.0:80 significa che la porta è aperta per tutte le indirizzi IPv4. 80 è la porta HTTP predefinita che offre l’accesso al sito web.

Verifica se una Porta è Aperta Usando ss

Il comando ss è un’altra utility da riga di comando per verificare le porte aperte. Questo comando mostra le statistiche del socket, che puoi utilizzare per confermare se una porta è aperta o meno. Il comando ss fornisce più informazioni sulle porte aperte rispetto ad altri strumenti.

Come il comando netstat, l’opzione -t indica a ss di visualizzare solo i socket TCP, -u per visualizzare solo i socket UDP e -l per mostrare solo i socket in ascolto. L’opzione -p indica il nome del processo o il PID che utilizza la porta.

ss -tulpn | grep LISTEN | grep :80

Se la porta è aperta, vedrai il seguente output. Come puoi notare, l’output contiene il nome del processo e il PID per ogni porta in ascolto. In questo caso, la porta 80 è aperta e viene utilizzata dal server web NGINX.

Verifica se una porta è aperta utilizzando lsof

Il comando lsof è un altro strumento utile per verificare le porte aperte. Il nome lsof sta per list open files, che visualizza informazioni sui file aperti nel sistema. Queste informazioni includono descrittori di file, ID processo, ID utente, ecc.

Come può aiutarti elencare i file aperti a determinare se una porta è aperta? Probabilmente hai già sentito la frase “tutto in Linux è un file”, e questa frase significa proprio quello che dice.

Ad esempio, supponiamo che tu voglia verificare se la porta 22 è aperta e i tuoi utenti possono connettersi al tuo server tramite SSH. Esegui il comando sottostante per elencare i file aperti con connessioni attive sulla porta 22.

Il flag -i istruisce lsof a visualizzare tutti i socket Internet aperti. Il flag -P mostra i numeri di porta invece dei nomi dei servizi. E il flag -n sopprime le ricerche DNS e dei nomi dei servizi, quindi vedrai gli indirizzi IP invece dei nomi degli host remoti.

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

Se la porta è aperta, vedrai l’output seguente. Come puoi vedere, l’output contiene informazioni su:

• 1027 è l'ID del processo del servizio sshd.
• root è l'ID utente che sta utilizzando la porta.
• 3u e 4u sono i descrittori di file per IPv4 e IPv6, rispettivamente.
• 31035 e 31037 sono le porte di rete per IPv4 e IPv6, rispettivamente.
• :22 indica che la porta 22 è aperta per tutti gli indirizzi IPv4 e IPv6.
• (LISTEN) indica che la porta è in ascolto per le connessioni in ingresso.
• 0t0 è lo stato del socket, il che significa che il socket è nello stato di ascolto.

Verifica se una porta è aperta utilizzando nmap

Fino a questo punto, hai visto come controllare se una porta è aperta su Linux usando la riga di comando. Ma cosa succede se vuoi controllare se una porta è aperta su una macchina remota? In tal caso, puoi utilizzare lo strumento nmap.

Ma prima di eseguire nmap, sii consapevole che questo strumento potrebbe non far parte dei pacchetti predefiniti nella tua distribuzione Linux. In tal caso, devi prima installare nmap eseguendo il comando seguente.

apt install nmap -y

Correlati:Scansioni di Porte Linux Efficaci per l’Amministratore di Rete

Ora, esegui il seguente comando per verificare se una porta è aperta su una macchina remota. Questo comando verifica se la porta 22 è aperta su 159.89.176.25 in modo che il tuo utente possa connettersi via SSH al tuo server. Sostituisci l’indirizzo IP con il tuo, se necessario.

nmap -p 22 159.89.176.25

Come puoi vedere, l’output contiene informazioni su:

• L’orario di inizio della scansione delle porte (2022-06-30 16:58 UTC).
• L’indirizzo IP della macchina remota (159.89.176.25).
• Lo stato della porta (aperta).
• Il servizio che utilizza la porta (ssh).
• Lo stato dell’host (attivo).

Il risultato conferma che gli utenti possono connettersi via SSH al computer utilizzando l’indirizzo IP e la porta.

ssh [email protected] -p 22

Lo screenshot qui sotto mostra una connessione SSH riuscita al server, dimostrando che la porta 22 è aperta.

Correlati:Sfrutta SSH e PowerShell per Trasferire File in Modo Sicuro Ora

Verifica se una Porta è Aperta da uno Script Shell

L’automazione è sempre una buona idea. Controllare le porte aperte eseguendo uno script shell è un ottimo modo per testare più porte. Puoi utilizzare metodi precedenti per verificare se una porta è aperta. Ma, per questo esempio, scriverai uno script shell di base che esegue il comando Netcat nc.

Correlato:Come utilizzare Netcat e potenziare le tue competenze di rete!

1. Crea un file chiamato check_port.sh nella tua directory home utilizzando il tuo editor di testo preferito. In questo esempio si utilizza nano.

nano check_port.sh

Correlato:Come modificare i file con un vero editor di testo di PowerShell

2. Copia il codice di esempio qui sotto nel tuo editor. Sostituisci 80 con il numero di porta che desideri controllare.

La condizione if controlla se la porta 80 è aperta utilizzando il comando nc. I comandi 2>&1 e >/dev/null reindirizzano gli errori e i messaggi di output rispettivamente su /dev/null. Il file /dev/null è un file speciale che scarta tutto ciò che riceve.

Se la porta è aperta, lo script check_port.sh stamperà Online sulla console. In caso contrario, lo script stamperà Offline.

Correlato:Comprendere Bash If Else e altre istruzioni condizionali

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

Il file dello script dovrebbe assomigliare allo screenshot sottostante. Salva lo script ed esci dall’editor.

3. Esegui lo script shell per iniziare a controllare le porte aperte specificate nello script.

bash check_port.sh

Vedrai uno dei seguenti output a seconda che la porta sia aperta. In questo caso, la porta è aperta, come conferma il messaggio Online.

Puoi utilizzare questo script shell per verificare se una porta è aperta a intervalli o in un lavoro pianificato. La creazione di script è particolarmente utile quando devi controllare più server. Devi solo copiare questo script check_port.sh su tutti i server che desideri controllare ed eseguirlo utilizzando strumenti CI/CD come Jenkins o Ansible.

Correlato:Automazione altamente efficace con Ansible AWX

Verifica se una porta è aperta utilizzando PowerShell

PowerShell ha un cmdlet integrato per testare le connessioni di rete chiamato Test-NetConnection – ma questo cmdlet è disponibile solo su sistemi Windows. Non preoccuparti; puoi comunque utilizzare PowerShell in Linux per controllare porte aperte e connessioni utilizzando la classe TcpClient.

Se il tuo computer Linux non ha ancora PowerShell, installalo seguendo le istruzioni in questa documentazione di Microsoft: Installare PowerShell su Linux.

1. Avvia PowerShell eseguendo il comando seguente.

pwsh

2. Successivamente, crea un file chiamato Test-Port.ps1 utilizzando il tuo editor di testo. In questo esempio viene utilizzato nano.

nano Test-Port.ps1

3. Successivamente, copia il codice sottostante nel tuo editor. Salva il file ed esci dall’editor successivamente.

Nota: Questo codice è un estratto del Strumento di Test Porte All-in-One PowerShell.

<#
	.SINOPSIS
		Questa funzione testa le porte TCP/UDP aperte.
	.DESCRIPTION
		Questa funzione testa qualsiasi porta TCP/UDP per vedere se è aperta o chiusa.
	.NOTE

	.PARAMETRO NomeComputer
		Uno o più nomi di computer remoti, separati da virgola
	.PARAMETRO Porta
		Uno o più numeri di porta separati da virgola che si desidera testare.
	.PARAMETRO TcpTimeout
		Il numero di millisecondi che la funzione aspetterà prima di dichiarare
		la porta TCP chiusa. Il valore predefinito è 1000.
	.ESEMPIO
		PS> Test-Port -NomeComputer 'LABDC','LABDC2' -Protocollo TCP 80,443
		
		Questo esempio testa le porte di rete TCP 80 e 443 sia su LABDC
		che su LABDC2.
	#>
[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. Dopo aver salvato lo script Test-Port.ps1, eseguire il comando sottostante per testare le porte 22, 80, 443 e 53.

Il parametro -NomeComputer accetta l’elenco dei nomi host, FQDN o indirizzi IP della/e macchina/e di destinazione.

Il parametro -Porta accetta un array di uno o più numeri di porta da testare.

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

Come puoi vedere di seguito, il risultato mostra che le porte 22 e 80 sono aperte (True), mentre la porta 443 no (False).

Per eseguire lo stesso script su più endpoint di destinazione e porte, modificare il codice sottostante per aggiungere tutti i computer di destinazione nel parametro NomeComputer e i numeri di porta nel parametro Porta.

./Test-Port.ps1 `
    -ComputerName adamtheautomator.com,localhost,8.8.8.8 `
    -Port 22,80,443,53

Conclusione

In questo articolo, hai appreso come verificare se una porta è aperta o chiusa in Linux. Hai anche imparato a controllare lo stato di una porta tramite uno script di shell e PowerShell. Ora puoi utilizzare uno qualsiasi di questi metodi per verificare se una porta è aperta sul tuo computer o su qualsiasi altro computer remoto.

Non fermarti qui, però. Dai un’occhiata ad altri articoli di risoluzione dei problemi per continuare a perfezionare le tue competenze di amministratore di sistema!