È possibile eseguire il ping di un indirizzo:port?

Le porte sono un concetto di UDP e TCP . I messaggi ping sono tecnicamente denominati ICMP Echo Request e ICMP Echo Reply che fanno parte di ICMP . ICMP, TCP, e UDP sono “fratelli”; non sono basati l'uno sull'altro, ma sono tre protocolli separati che girano sopra IP.

Pertanto non è possibile ping una porta. Quello che si può fare è usare uno scanner di porte come nmap.

nmap -p 80 onofri.org

Si può anche usare telnet onofri.org 80, come suggerito in una delle altre risposte (darà un errore se la porta è chiusa o filtrata).

Io uso Telnet , dal momento che è integrato in molte piattaforme senza download aggiuntivi.

Basta usare il comando telnet per connettersi alla porta che si vuole testare. Se si riceve il messaggio qui sotto, o un messaggio dal servizio stesso, allora la porta è viva.

Minty16 ~ $ telnet localhost 139
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
``` ```
Minty16 ~ $ telnet localhost 5000
Trying 127.0.0.1...
telnet: Unable to connect to remote host: Connection refused

Se si conosce la sequenza di comando per il servizio a cui ci si connette, si può digitare un comando HTTP/FTP GET per esempio) e osservare la risposta e l'uscita nel terminale. Questo è molto utile per testare il servizio stesso, poiché vi mostrerà le informazioni di errore inviate al cliente, come gli errori HTTP 500.

Se si riceve un messaggio che la connessione è stata rifiutata, la porta è chiusa.

&001

È possibile utilizzare netcat per connettersi a una porta specifica per vedere se si ottiene una connessione. Il flag -v aumenterà la verbosità per mostrare se la porta è aperta o chiusa. Il flag -z farà uscire netcat una volta che ha una connessione. Potete quindi usare i codici di uscita attraverso $? per vedere se la connessione è stata stabilita o meno.

$ nc -zv localhost 22
localhost [127.0.0.1] 22 (ssh) open
$ echo $?
0
$ nc -zv localhost 23
localhost [127.0.0.1] 23 (telnet) : Connection refused
$ echo $?
1
``` ```
$ date;nc -z -w 1 www.google.com 8000;date
Fri Jun 20 15:55:26 PDT 2014
Fri Jun 20 15:55:27 PDT 2014
$ date;nc -z -w 4 www.google.com 8000;date
Fri Jun 20 15:55:33 PDT 2014
Fri Jun 20 15:55:37 PDT 2014

$ nc -h
[v1.10-40]

Inoltre, potete usare mtr con il flag -T per tcp e il flag -P per specificare una porta. Questo farà qualcosa di simile a un traceroute su TCP invece che solo ICMP. Questo potrebbe essere eccessivo, tuttavia.

sigh Devo modificare per aggiungere questo bit, dato che non possiamo inserire codice nei commenti. Knoppix potrebbe fare qualcosa di diverso con la sua versione di netcat, ma questo è ciò che ottengo da Linux Mint

&001

Sì, usare HPing per farlo:

$ sudo hping -S -p 80 google.com
HPING google.com (p5p1 77.237.27.37): S set, 40 headers + 0 data bytes
len=46 ip=77.237.27.37 ttl=58 id=25706 sport=80 flags=SA seq=0 win=29200 rtt=7.5 ms
len=46 ip=77.237.27.37 ttl=58 id=25707 sport=80 flags=SA seq=1 win=29200 rtt=7.4 ms
len=46 ip=77.237.27.37 ttl=58 id=25708 sport=80 flags=SA seq=2 win=29200 rtt=8.5 ms
len=46 ip=77.237.27.37 ttl=58 id=25709 sport=80 flags=SA seq=3 win=29200 rtt=7.8 ms
^C
--- google.com hping statistic ---
4 packets transmitted, 4 packets received, 0% packet loss
round-trip min/avg/max = 7.4/7.8/8.5 ms

Si noti che ha bisogno di privilegi di root (o capacità SELinux) per creare pacchetti IP grezzi, proprio come il ping (che molto probabilmente è suid sul vostro sistema).

È possibile utilizzare Paping , un cross-platform TCP port testing, emulando la funzionalità di ping (ping porta)

(vedi anche Github poiché code.google.com è stato ammortizzato)

paping -p 80 google.com

Si potrebbe anche utilizzare nping (parte di nmap):

$ nping -p 80 localhost

Starting Nping 0.6.00 ( http://nmap.org/nping ) at 2014-06-23 11:57 CEST
SENT (0.0015s) Starting TCP Handshake > localhost:80 (127.0.0.1:80)
RECV (0.0016s) Handshake with localhost:80 (127.0.0.1:80) completed
SENT (1.0027s) Starting TCP Handshake > localhost:80 (127.0.0.1:80)
RECV (1.0027s) Handshake with localhost:80 (127.0.0.1:80) completed
SENT (2.0038s) Starting TCP Handshake > localhost:80 (127.0.0.1:80)
RECV (2.0039s) Handshake with localhost:80 (127.0.0.1:80) completed
SENT (3.0050s) Starting TCP Handshake > localhost:80 (127.0.0.1:80)
RECV (3.0050s) Handshake with localhost:80 (127.0.0.1:80) completed
SENT (4.0061s) Starting TCP Handshake > localhost:80 (127.0.0.1:80)
RECV (4.0062s) Handshake with localhost:80 (127.0.0.1:80) completed

Max rtt: 0.032ms | Min rtt: 0.008ms | Avg rtt: 0.012ms
TCP connection attempts: 5 | Successful connections: 5 | Failed: 0 (0.00%)
Tx time: 4.00575s | Tx bytes/s: 99.86 | Tx pkts/s: 1.25
Rx time: 4.00575s | Rx bytes/s: 49.93 | Rx pkts/s: 1.25
Nping done: 1 IP address pinged in 4.01 seconds

Si può fare questo nel guscio con Python come un liner non così corto:

$ portping() { python <<<"import socket; socket.setdefaulttimeout(1); socket.socket().connect(('$1', $2))" 2> /dev/null && echo OPEN || echo CLOSED; }
$ portping 8.8.8.8 54
CLOSED
$ portping 8.8.8.8 53
OPEN

Solo per riferimento, ha voluto condividere un post di Vivek Gite: https://www.cyberciti.biz/faq/ping-test-a-specific-port-of-machine-ip-address-using-linux-unix/#comment-920398

Egli elenca vari modi, alcuni dei quali sono già pubblicati qui. Ma il più sorprendente per me non era altro che bash:

(echo >/dev/tcp/{host}/{port}) &>/dev/null && echo "opened" || echo "closed"
(echo >/dev/udp/{host}/{port}) &>/dev/null && echo "opened" || echo "closed"
(echo >/dev/tcp/www.cyberciti.biz/22) &>/dev/null && echo "Opened 22" || echo "Closed 22"
(echo >/dev/tcp/www.cyberciti.biz/443) &>/dev/null && echo "Opened 443" || echo "Closed 443"

o una versione super semplice: basta guardare l'uscita del seguente schema di comando:

echo >/dev/{tcp|udp}/{host}/{port}
``` &001 



Utile quando si lavora con i container docker casuali.

Aggiungo qui lo strumento watch:

watch nmap -p22,80 google.com &007

Every 2,0s: nmap -p22,80 google.com Mon Jun 15 16:46:33 2015

Starting Nmap 6.40 ( http://nmap.org ) at 2015-06-15 16:46 NOVT
Nmap scan report for google.com (127.0.0.1)
Host is up (0.0012s latency).
rDNS record for 127.0.0.1: google.com
PORT STATE SERVICE
22/tcp open ssh
80/tcp closed http

Nmap done: 1 IP address (1 host up) scanned in 0.18 seconds

È semplice con nmap

esempi:

#sintaxis
nmap -p [port] hostName
#first is command, after scan ports, type port - port or range ports, and ip or name of website...

## Scan port 80
nmap -p 80 onofri.org

## Scan TCP port 80
nmap -p T:80 onofri.org

## Scan UDP port 53
nmap -p U:53 onofri.org

## Scan two ports ##
nmap -p 80,443 onofri.org

## Scan port ranges ##
nmap -p 80-200 onofri.org

## Combine all options ##
nmap -p U:53,111,137,T:21-25,80,139,8080 onofri.org
nmap -p U:53,111,137,T:21-25,80,139,8080 server1.cyberciti.biz
nmap -v -sU -sT -p U:53,111,137,T:21-25,80,139,8080 onofri.org

## Scan all ports with * wildcard ##
nmap -p "*" 192.168.1.1

## Scan top ports i.e. scan $number most common ports ##
nmap --top-ports 5 onofri.org
nmap --top-ports 10 onofri.org

Per ulteriori informazioni vedere questo:

digitare a riga di comando questo: man nmap http://www.cyberciti.biz/networking/nmap-command-examples-tutorials/ http://www.tecmint.com/nmap-command-examples/

State cercando di testare la comunicazione o di ottenere una risposta dalla porta 80 su quel nodo? PING cercherà di stabilire la comunicazione con un host specifico attraverso ICMP che non ha nulla a che fare con le porte.

Invece provate http://nmap.org/ per controllare le informazioni sulla porta e testare la comunicazione:

nmap -v -p 80 onofri.org