Todas as maneiras de verificar se uma porta está aberta no Linux

Tutoriais
Linux Networking

O seu servidor Linux está em execução, e agora você quer verificar se uma porta específica está aberta para que você possa acessá-la remotamente. Verificar as portas abertas é uma tarefa bastante comum para administradores de sistema, e existem algumas maneiras diferentes de fazê-lo no Linux.

Neste artigo, você aprenderá várias maneiras de verificar se uma porta está aberta no Linux para que você possa escolher as que funcionam melhor para você. Pronto? Continue lendo!

Pré-requisitos

Este tutorial será uma demonstração prática. Se você deseja acompanhar, certifique-se de ter o seguinte.

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

Relacionado:Como Instalar o Ubuntu 20.04 [Passo a Passo]

  • Acesso a um terminal. Se você usa um ambiente de desktop gráfico, procure por um programa emulador de terminal no menu de aplicativos. Ou, se você fez login em um servidor remoto via SSH,

Relacionado:Um Cara do Windows em um Mundo Linux: Configurando o Comando SSH

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

Verificar Se uma Porta Está Aberta no Linux Usando o netstat

O primeiro método para verificar se uma porta está aberta no Linux é executando o comando netstat. Este comando exibe conexões de rede, tabelas de roteamento e muitas estatísticas de interface de rede.

O comando netstat faz parte do pacote net-tools, e este pacote pode não vir por padrão com sua distribuição Linux. No Ubuntu, instale o netstat executando os seguintes comandos no terminal.

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

Relacionado:Aprendendo o Apt Get do Ubuntu Através de Exemplos

Suponha que você tenha um servidor web NGINX em execução e queira verificar se a porta 80 está aberta. Você pode fazer isso executando o seguinte comando. Substitua 80 pelo número da porta que deseja verificar.

As bandeiras -tulpn instruem o netstat a exibir todas as portas em escuta. O primeiro comando grep encontra e filtra a linha contendo a palavra LISTEN no resultado. O segundo comando grep filtra os resultados para exibir apenas aqueles itens que correspondem a :80.

netstat -tulpn | grep LISTEN | grep :80

Relacionado:Como Pesquisar via Grep com Regex

Para saber mais sobre as bandeiras do netstat, execute o comando netstat –help.

Se a porta estiver aberta, você verá a seguinte saída. Como pode ser visto, a saída mostra que a porta 80 está aberta no sistema. tcp é o tipo de protocolo, e :::80 indica que é uma porta TCPv6. 0.0.0.0:80 significa que a porta está aberta para todos os endereços IPv4. 80 é a porta padrão HTTP que serve o acesso ao site.

Checking If a Port is Open with netstat

Verificando se uma Porta Está Aberta Usando ss

O comando ss é mais uma utilidade de linha de comando para verificar portas abertas. Este comando exibe estatísticas do socket, que você pode usar para confirmar se uma porta está aberta ou não. O comando ss mostra mais informações sobre portas abertas do que outras ferramentas.

Assim como o comando netstat, a opção -t instrui o ss a exibir apenas sockets TCP, -u para exibir apenas sockets UDP, e -l para mostrar apenas sockets de escuta. A opção -p indica o nome do processo ou PID que está utilizando a porta.

ss -tulpn | grep LISTEN | grep :80

Se a porta estiver aberta, você verá a seguinte saída. Como mostrado, a saída contém o nome do processo e o PID para cada porta de escuta. Neste caso, a porta 80 está aberta, e o servidor web NGINX está a utilizá-la.

Checking If a Port is Open Using ss

Verificando Se uma Porta Está Aberta Usando o lsof

O comando lsof é outra ferramenta útil para verificar portas abertas. O nome lsof significa listar arquivos abertos, que exibe informações sobre arquivos abertos no sistema. Essas informações incluem descritores de arquivos, IDs de processo, IDs de usuário, etc.

Como listar arquivos abertos ajuda a determinar se uma porta está aberta? Você provavelmente já ouviu a frase “tudo no Linux é um arquivo” — e essa frase significa o que diz.

Por exemplo, se você quiser verificar se a porta 22 está aberta e se seus usuários podem fazer SSH no seu servidor, execute o comando abaixo para listar arquivos abertos com conexões ativas na porta 22.

A bandeira -i instrui o lsof a exibir todos os sockets de Internet abertos. A bandeira -P mostra os números das portas em vez dos nomes dos serviços. E a bandeira -n suprime as pesquisas de DNS e de nomes de serviço, então você verá os endereços IP em vez dos nomes dos hosts remotos.

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

Se a porta estiver aberta, você verá a seguinte saída. Como pode ver, a saída contém informações sobre:

  • 1027 é o ID do processo do serviço sshd.
  • root é o ID do usuário que está usando a porta.
  • 3u e 4u são os descritores de arquivo para IPv4 e IPv6, respectivamente.
  • 31035 e 31037 são as portas de rede para IPv4 e IPv6, respectivamente.
  • :22 indica que a porta 22 está aberta para todos os endereços IPv4 e IPv6.
  • (LISTEN) mostra que a porta está ouvindo conexões de entrada.
  • 0t0 é o estado do socket, o que significa que o socket está no estado LISTEN.
Checking If a Port is Open Using lsof

Verificando Se uma Porta Está Aberta Usando o nmap

Até agora, você viu como verificar se uma porta está aberta no Linux usando a linha de comando. Mas e se você quiser verificar se uma porta está aberta em uma máquina remota? Nesse caso, você pode usar a ferramenta nmap.

Mas antes de executar o nmap, esteja ciente de que essa ferramenta pode não fazer parte dos pacotes padrão em sua distribuição Linux. Nesse caso, você deve primeiro instalar o nmap executando o comando abaixo.

apt install nmap -y

Relacionado:Varreduras Efetivas de Portas Linux para o Administrador de Rede

Agora, execute o seguinte comando para verificar se uma porta está aberta em uma máquina remota. Este comando testa se a porta 22 está aberta em 159.89.176.25 para que seu usuário possa fazer SSH no seu servidor. Substitua o endereço IP conforme necessário com o seu.

nmap -p 22 159.89.176.25

Como você pode ver, a saída contém informações sobre:

  • O horário de início da varredura de portas (2022-06-30 16:58 UTC).
  • O endereço IP da máquina remota (159.89.176.25).
  • O estado da porta (aberta).
  • O serviço que está usando a porta (ssh).
  • O estado do host (ativo).
Checking If a Port is Open Using nmap

O resultado confirma que os usuários podem fazer SSH no computador usando o endereço IP e a porta.

ssh [email protected] -p 22

A captura de tela abaixo mostra uma conexão SSH bem-sucedida com o servidor, comprovando que a porta 22 está aberta.

SSHing into your server

Relacionado:Aproveite o SSH e o PowerShell para Transferir Arquivos com Segurança Agora

Testando se uma Porta Está Aberta a partir de um Script de Shell

A automação é sempre uma boa ideia. Verificar portas abertas executando um script de shell é uma excelente maneira de testar várias portas. Você pode usar quaisquer métodos anteriores para verificar se uma porta está aberta. Mas, para este exemplo, você estará escrevendo um script de shell básico que executa o comando Netcat nc.

Relacionado:Como Usar o Netcat e Aprimorar Suas Habilidades em Rede!

1. Crie um arquivo chamado check_port.sh no seu diretório pessoal usando o editor de texto de sua preferência. Neste exemplo, usaremos o nano.

nano check_port.sh

Relacionado:Como Editar Arquivos com um Editor de Texto Real no PowerShell

2. Copie o código de exemplo abaixo para o seu editor. Substitua 80 pelo número da porta que você deseja verificar.

A condição if verifica se a porta 80 está aberta usando o comando nc. O 2>&1 e >/dev/null redirecionam os erros e mensagens de saída para /dev/null, respectivamente. O /dev/null é um arquivo especial que descarta tudo o que recebe.

Se a porta estiver aberta, o script check_port.sh imprimirá “Online” no console. Caso contrário, o script imprimirá “Offline”.

Relacionado:Entendendo o Bash If Else e Outras Declarações Condicionais

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

O arquivo do script deve se parecer com a captura de tela abaixo. Salve o script e saia do editor.

Creating the Shell script

3. Execute o script shell para começar a verificar as portas abertas especificadas no script.

bash check_port.sh

Você verá uma das mensagens a seguir, dependendo se a porta está aberta. Neste caso, a porta está aberta, como confirma a mensagem Online.

Check if the 80 port is open

Você pode usar este script shell para verificar se uma porta está aberta em um intervalo ou como um trabalho agendado. A criação de scripts é especialmente útil quando você precisa verificar vários servidores. Você só precisa copiar este script check_port.sh para todos os servidores que deseja verificar e executá-lo usando ferramentas de CI/CD como Jenkins ou Ansible.

Relacionado:Automação Altamente Eficiente com Ansible AWX

Testando Se uma Porta Está Aberta Usando o PowerShell

O PowerShell possui um cmdlet integrado para testar conexões de rede chamado Test-NetConnection — mas esse cmdlet está disponível apenas em sistemas Windows. Não se preocupe; você ainda pode usar o PowerShell no Linux para verificar portas abertas e conexões usando a classe TcpClient.

Se o seu computador Linux ainda não tiver o PowerShell, instale-o seguindo as instruções nesta documentação da Microsoft: Instalar o PowerShell no Linux.

1. Inicie o PowerShell executando o comando abaixo.

pwsh
Launching PowerShell

2. Em seguida, crie um arquivo chamado Test-Port.ps1 usando o seu editor de texto. Este exemplo utiliza o nano.

nano Test-Port.ps1

3. Depois, copie o código abaixo para o seu editor. Salve o arquivo e saia do editor em seguida.

Nota: Este código é um excerto da Ferramenta de Teste de Porta All-in-One PowerShell.

<#
	.SINOPSE
		Essa função testa portas TCP/UDP abertas.
	.DESCRIÇÃO
		Essa função testa qualquer porta TCP/UDP para ver se está aberta ou fechada.
	.NOTAS

	.PARAMETER NomeDoComputador
		Um ou mais nomes de computador remotos, separados por vírgula
	.PARAMETER Porta
		Um ou mais números de porta, separados por vírgula, que você gostaria de testar.
	.PARAMETER TcpTimeout
		O número de milissegundos que a função aguardará até declarar
		a porta TCP como fechada. O padrão é 1000.
	.EXEMPLO
		PS> Test-Port -NomeDoComputador 'LABDC','LABDC2' -Protocolo TCP 80,443
		
		Este exemplo testa as portas de rede TCP 80 e 443 nos servidores LABDC
		e 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. Após salvar o script Test-Port.ps1, execute o comando abaixo para testar as portas 22, 80, 443 e 53.

O parâmetro -NomeDoComputador aceita a lista de nomes de host, FQDN ou endereços IP da(s) máquina(s) de destino.

O parâmetro -Porta aceita um array de um ou mais números de porta para teste.

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

Como você pode ver abaixo, o resultado mostra que as portas 22 e 80 estão abertas (True), enquanto a porta 443 não está (False).

Checking for open ports using PowerShell scripting

Para executar o mesmo script contra vários destinos e portas, edite o código abaixo para adicionar todos os computadores de destino no parâmetro NomeDoComputador e os números de porta no parâmetro Porta.

./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

Conclusão

Neste artigo, você aprendeu como verificar se uma porta está aberta ou não no Linux. Você também aprendeu a verificar se uma porta está aberta a partir de um script de shell e do PowerShell. Agora, você pode usar qualquer um desses métodos para verificar se uma porta está aberta em sua máquina ou em qualquer máquina remota.

Não pare por aqui, porém. Confira outros artigos de resolução de problemas para continuar a aprimorar suas habilidades de administrador de sistema!

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