Comment ouvrir un port sur Linux

Introduction

A port is a communication endpoint. Within an operating system, a port is opened or closed to data packets for specific processes or network services.

Typiquement, les ports identifient un service réseau spécifique qui leur est assigné. Cela peut être modifié en configurant manuellement le service pour utiliser un port différent, mais en général, les valeurs par défaut peuvent être utilisées.

Les 1024 premiers ports (numéros de port 0 à 1023) sont appelés numéros de ports bien connus et sont réservés pour les services les plus couramment utilisés. Cela inclut SSH (port 22), HTTP (port 80), HTTPS (port 443).

Les numéros de ports au-dessus de 1024 sont appelés ports éphémères.

• Les numéros de ports 1024 à 49151 sont appelés les ports enregistrés/utilisateur.
• Les numéros de ports 49152 à 65535 sont appelés les ports dynamiques/privés.

Dans ce tutoriel, vous ouvrirez un port éphémère sur Linux, car les services les plus courants utilisent les ports bien connus.

Prérequis

Pour compléter ce tutoriel, vous aurez besoin de :

• La familiarité avec l’utilisation du terminal.

Listez tous les ports ouverts

Avant d’ouvrir un port sur Linux, vous devez vérifier la liste de tous les ports ouverts et choisir un port éphémère qui ne figure pas dans cette liste.

Utilisez la commande netstat pour lister tous les ports ouverts, y compris TCP et UDP, qui sont les protocoles les plus courants pour la transmission de paquets dans la couche réseau.

netstat -lntu

Cela affichera :

• tous les sockets en écoute (-l)
• le numéro du port (-n)
• Les ports TCP (-t)
• Les ports UDP (-u)

Output
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address    Foreign Address  State
tcp        0      0 127.0.0.1:5432   0.0.0.0:*        LISTEN
tcp        0      0 127.0.0.1:27017  0.0.0.0:*        LISTEN
tcp        0      0 127.0.0.1:6379   0.0.0.0:*        LISTEN
tcp        0      0 127.0.0.53:53    0.0.0.0:*        LISTEN
tcp        0      0 0.0.0.0:22       0.0.0.0:*        LISTEN
tcp6       0      0 ::1:5432         :::*             LISTEN
tcp6       0      0 ::1:6379         :::*             LISTEN
tcp6       0      0 :::22            :::*             LISTEN
udp        0      0 127.0.0.53:53    0.0.0.0:*        LISTEN

Vérifiez que vous recevez des sorties cohérentes en utilisant la commande ss pour lister les sockets en écoute avec un port ouvert :

ss -lntu

Cela affichera :

Output
Netid  State   Recv-Q  Send-Q    Local Address:Port   Peer Address:Port
udp    UNCONN  0       0         127.0.0.53%lo:53          0.0.0.0:*
tcp    LISTEN  0       128           127.0.0.1:5432        0.0.0.0:*
tcp    LISTEN  0       128           127.0.0.1:27017       0.0.0.0:*
tcp    LISTEN  0       128           127.0.0.1:6379        0.0.0.0:*
tcp    LISTEN  0       128       127.0.0.53%lo:53          0.0.0.0:*
tcp    LISTEN  0       128             0.0.0.0:22          0.0.0.0:*
tcp    LISTEN  0       128               [::1]:5432        0.0.0.0:*
tcp    LISTEN  0       128               [::1]:6379        0.0.0.0:*
tcp    LISTEN  0       128                [::]:22          0.0.0.0:*

Cela donne plus ou moins les mêmes ports ouverts que netstat.

Ouverture d’un port sur Linux pour autoriser les connexions TCP

Maintenant, ouvrez un port fermé et faites-le écouter les connexions TCP.

Pour les besoins de ce tutoriel, vous ouvrirez le port 4000. Cependant, si ce port n’est pas ouvert sur votre système, n’hésitez pas à choisir un autre port fermé. Assurez-vous simplement qu’il est supérieur à 1023.

Assurez-vous que le port 4000 n’est pas utilisé en utilisant la commande netstat:

netstat -na | grep :4000

Ou la commande ss:

ss -na | grep :4000

La sortie doit rester vide, vérifiant ainsi qu’il n’est pas actuellement utilisé, afin que vous puissiez ajouter manuellement les règles de port au pare-feu iptables du système.

Pour les utilisateurs d’Ubuntu et les systèmes basés sur ufw

Utilisez ufw – le client en ligne de commande pour le pare-feu UncomplicatedFirewall.

Vos commandes ressembleront à ceci :

sudo ufw allow 4000

Référez-vous à Comment configurer une configuration de pare-feu ufw pour votre distribution.

Pour CentOS et les systèmes basés sur firewalld

Utilisez firewall-cmd – le client en ligne de commande pour le démon firewalld.

Vos commandes ressembleront à ceci :

firewall-cmd --add-port=4000/tcp

Référez-vous à Comment configurer firewalld pour votre distribution.

Pour d’autres distributions Linux

Utilisez iptables pour modifier les règles de filtrage des paquets IPv4 du système.

iptables -A INPUT -p tcp --dport 4000 -j ACCEPT

Référez-vous à Comment configurer un pare-feu avec iptables pour votre distribution.

Tester le port TCP nouvellement ouvert pour les connexions TCP

Maintenant que vous avez ouvert avec succès un nouveau port TCP, il est temps de le tester.

Tout d’abord, lancez netcat (nc) et écoutez (-l) sur le port (-p) 4000, tout en envoyant la sortie de ls à n’importe quel client connecté:

ls | nc -l -p 4000

Maintenant, après qu’un client ait ouvert une connexion TCP sur le port 4000, il recevra la sortie de ls. Laissez cette session tranquille pour le moment.

Ouvrez une autre session de terminal sur la même machine.

Étant donné que vous avez ouvert un port TCP, utilisez telnet pour vérifier la connectivité TCP. Si la commande n’existe pas, installez-la à l’aide de votre gestionnaire de paquets.

Entrez l’IP de votre serveur et le numéro de port (4000 dans cet exemple) et exécutez cette commande:

telnet localhost 4000

Cette commande tente d’ouvrir une connexion TCP sur localhost sur le port 4000.

Vous obtiendrez une sortie similaire à ceci, indiquant qu’une connexion a été établie avec le programme en écoute (nc):

Output
Trying ::1...
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
while.sh

La sortie de ls (while.sh, dans cet exemple) a également été envoyée au client, indiquant une connexion TCP réussie.

Utilisez nmap pour vérifier si le port (-p) est ouvert :

nmap localhost -p 4000

Cette commande vérifiera le port ouvert :

Output
Starting Nmap 7.60 ( https://nmap.org ) at 2020-01-18 21:51 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.00010s latency).
Other addresses for localhost (not scanned): ::1

PORT     STATE SERVICE
4000/tcp open  remoteanything

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

Le port a été ouvert. Vous avez réussi à ouvrir un nouveau port sur votre système Linux.

Mais ceci est seulement temporaire, car les changements seront réinitialisés à chaque fois que vous redémarrez le système.

Règles persistantes

L’approche présentée dans cet article mettra à jour temporairement les règles du pare-feu jusqu’à ce que le système s’éteigne ou redémarre. Des étapes similaires doivent donc être répétées pour ouvrir le même port à nouveau après un redémarrage.

Pour le pare-feu ufw

Les règles ufw ne se réinitialisent pas au redémarrage. Cela est dû à son intégration dans le processus de démarrage, et le noyau enregistre les règles du pare-feu en utilisant ufw en appliquant des fichiers de configuration appropriés.

Pour firewalld

Vous devrez appliquer le drapeau --permanent.

Consultez Comment configurer firewalld pour votre distribution.

Pour iptables

Vous devrez enregistrer les règles de configuration. Ces tutoriels recommandent iptables-persistent.

Consultez Comment configurer un pare-feu en utilisant iptables pour votre distribution.

Conclusion

Dans ce tutoriel, vous avez appris comment ouvrir un nouveau port sur Linux et le configurer pour les connexions entrantes. Vous avez également utilisé netstat, ss, telnet, nc, et nmap.

Poursuivez votre apprentissage avec Comment fonctionne le pare-feu Iptables, Une plongée profonde dans l’architecture d’Iptables et Netfilter, Compréhension des sockets, et Comment utiliser Top, Netstat, Du et d’autres outils pour surveiller les ressources du serveur.