Test of een poort op een extern systeem bereikbaar is (zonder telnet)

Lekker verveeld! Van de man pagina’s. Enkele poort:

nc -zv 127.0.0.1 80

Meerdere poorten:

nc -zv 127.0.0.1 22 80 8080

Bereik van poorten:

nc -zv 127.0.0.1 20-30

Bash heeft al een tijdje toegang tot TCP en UDP -poorten. Vanaf de man pagina: /dev/tcp/host/port If host is a valid hostname or Internet address, and port is an integer port number or service name, bash attempts to open a TCP connection to the corresponding socket. /dev/udp/host/port If host is a valid hostname or Internet address, and port is an integer port number or service name, bash attempts to open a UDP connection to the corresponding socket.

. Dus je zou zoiets als dit kunnen gebruiken:

xenon-lornix:~> cat < /dev/tcp/127.0.0.1/22
SSH-2.0-OpenSSH_6.2p2 Debian-6
^C pressed here

Taa Daa!

Netcat is een nuttig hulpmiddel:

nc 127.0.0.1 123 &> /dev/null; echo $? Geeft 0 weer als poort 123 open is, en 1 als deze gesloten is.

De eenvoudigste methode, zonder gebruik te maken van een ander instrument, zoals socat, is zoals beschreven in het antwoord van @lornix hierboven. Dit is alleen maar om een actueel voorbeeld toe te voegen van hoe men gebruik zou maken van het psuedo-apparaat /dev/tcp/... binnen Bash als je bijvoorbeeld wilt testen of een andere server een bepaalde poort toegankelijk heeft via de commandoregel.

Voorbeelden

Zeg dat ik een host heb op mijn netwerk met de naam skinner.

$ (echo > /dev/tcp/skinner/22) >/dev/null 2>&1 \
    && echo "It's up" || echo "It's down"
It's up

$ (echo > /dev/tcp/skinner/222) >/dev/null 2>&1 && \
    echo "It's up" || echo "It's down"
It's down

De reden dat je de echo > /dev/... tussen haakjes wilt omwikkelen, (echo > /dev/...) is omdat als je dat niet doet, dan krijg je met tests van verbindingen die down zijn, dit soort berichten te zien.

$ (echo > /dev/tcp/skinner/223) && echo hi
bash: connect: Connection refused
bash: /dev/tcp/skinner/223: Connection refused

Deze kunnen niet eenvoudigweg worden omgeleid naar /dev/null omdat ze komen van de poging om data uit te schrijven naar het apparaat /dev/tcp. Dus we leggen al die uitvoer vast binnen een subcommando, d.w.z. (...cmds...) en sturen de uitvoer van het subcommando om.

Ik vond dat curl de klus op een soortgelijke manier als telnet kan klaren, en curl zal je zelfs vertellen welk protocol de luisteraar verwacht.

Construeer een HTTP URI van de hostnaam en de poort als eerste argument naar curl. Als curl verbinding kan maken, zal het een protocol mismatch rapporteren en zal het afsluiten (als de luisteraar geen webservice is). Als curl geen verbinding kan maken, zal het time out gaan.

Bijvoorbeeld, poort 5672 op host 10.0.0.99 wordt ofwel gesloten ofwel geblokkeerd door een firewall:

$ curl http://10.0.0.99:5672
curl: (7) couldn't connect to host

echter, vanaf een ander systeem, poort 5672 op host 10. 0.0.99 kan worden bereikt, en lijkt een AMQP luisteraar te draaien.

$ curl http://10.0.0.99:5672
curl: (56) Failure when receiving data from the peer
AMQP

Het is belangrijk om onderscheid te maken tussen de verschillende berichten: de eerste storing was omdat curl geen verbinding kon maken met de poort. De tweede storing is een succestest, maar curl verwachtte een HTTP listener in plaats van een AMQP listener.

[admin@automation-server 1.2.2]# nc -v -z -w2 192.168.193.173 6443
nc: connect to 192.168.193.173 port 6443 (tcp) failed: Connection refused

[admin@automation-server 1.2.2]# nc -v -z -w2 192.168.194.4 6443
Connection to 192.168.194.4 6443 port [tcp/sun-sr-https] succeeded!

Hoop dat het uw probleem oplost :)

Hier is one-liner:

</dev/tcp/localhost/11211 && echo Port is open || echo Port is closed

met behulp van Bash syntaxis uitgelegd in @lornix antwoord .

Voor meer info, check: Geavanceerde Bash-Scripting Gids: Hoofdstuk 29. /dev en /proc .

Ik heb een hele dag geworsteld omdat geen van deze antwoorden voor mij leek te werken. Het probleem is dat de meest recente versie van nc niet meer de -z vlag heeft, terwijl directe toegang via TCP (zoals volgens @lornix en @slm) faalt wanneer de host niet bereikbaar is. Uiteindelijk vond ik deze pagina , waar ik uiteindelijk niet één maar twee werkende voorbeelden vond:

1. nc -w1 127.0.0.1 22 </dev/null

2. timeout 1 bash -c '(echo > /dev/tcp/127.0.0.1/22) >/dev/null 2>&1'

Dan gebruik je gewoon && en/of || (of zelfs $?) om het resultaat te extraheren. Hopelijk vindt iemand deze informatie nuttig.

Door de antwoorden van @kenorb en @Azukikuru te combineren kunt u open/gesloten/gefileerde poorten testen.

timeout 1 bash -c '</dev/tcp/127.0.0.1/22 && echo Port is open || echo Port is closed' || echo Connection timeout

Een andere benadering met curl voor het bereiken van een willekeurige poort

curl telnet://127.0.0.1:22

Hier is een functie die een van de methoden zal kiezen, afhankelijk van wat er geïnstalleerd is op uw systeem:

# Check_port <address> <port> 
check_port() {
if ["$(which nc)" != ""]; then 
    tool=nc
elif ["$(which curl)" != ""]; then
     tool=curl
elif ["$(which telnet)" != ""]; then
     tool=telnet
elif [-e /dev/tcp]; then
      if ["$(which gtimeout)" != ""]; then  
       tool=gtimeout
      elif ["$(which timeout)" != ""]; then  
       tool=timeout
      else
       tool=devtcp
      fi
fi
echo "Using $tool to test access to $1:$2"
case $tool in
nc) nc -v -G 5 -z -w2 $1 $2 ;;
curl) curl --connect-timeout 10 http://$1:$2 ;;
telnet) telnet $1 $2 ;;
gtimeout) gtimeout 1 bash -c "</dev/tcp/${1}/${2} && echo Port is open || echo Port is closed" || echo Connection timeout ;;
timeout) timeout 1 bash -c "</dev/tcp/${1}/${2} && echo Port is open || echo Port is closed" || echo Connection timeout ;;
devtcp) </dev/tcp/${1}/${2} && echo Port is open || echo Port is closed ;;
*) echo "no tools available to test $1 port $2";;
esac

}
export check_port

Het zou niet op je doos moeten staan, maar probeer het met nmap.

ter referentie, voortbouwend op het antwoord van @peperunas:

de manier om nmap te gebruiken om te testen, is:

nmap -p 22 127.0.0.1

(bovenstaand voorbeeld gebruikt localhost voor demonstratiedoeleinden)

Als u meer moet testen dan op het systeem, kunt u onze testtool dda-serverspec https://github.com/DomainDrivenArchitecture/dda-serverspec-crate ) voor dergelijke taken gebruiken. U kunt uw verwachting

{:netcat [{:host "mywebserver.com" :port "443"}
          {:host "telnet mywebserver.com" :port "80"}
          {:host "telnet mywebserver.com" :port "8443"}]}

definiëren en deze verwachting testen tegen de localhost of tegen externe hosts (connect by ssh). Voor tests op afstand moet je een doelwit definiëren:

{:existing [{:node-name "test-vm1"
             :node-ip "35.157.19.218"}
            {:node-name "test-vm2"
             :node-ip "18.194.113.138"}]
 :provisioning-user {:login "ubuntu"}}

Je mag de test uitvoeren met java -jar dda-serverspec.jar --targets targets.edn serverspec.edn

Onder de motorkap gebruiken we netcat als proprosed hierboven …