Est-il possible d'exposer le tunnel TCP sous Linux en tant que périphérique de caractères spécial ?

socat peut faire cela et bien d'autres choses avec des choses ressemblant à des "flux"

Quelque chose utilisant cette idée de base devrait le faire pour vous :

Machine1$ socat tcp-l:54321,reuseaddr,fork pty,link=/tmp/netchardev,waitslave

Machine2$ socat pty,link=/tmp/netchardev,waitslave tcp:machine1:54321

(adapté de la page d'exemples)

Si vous souhaitez chiffrer, vous pouvez utiliser une variante de ssl-l:54321,reuseaddr,cert=server.pem,cafile=client.crt,fork sur machine1, et quelque chose comme ssl:server-host:1443,cert=client.pem,cafile=server.crt sur machine2

(En savoir plus sur socat ssl)

La transmission de messages doit être implémentée à une couche supérieure ; TCP n'a pas la notion de message -- les connexions TCP transfèrent des flux d'octets.

Vous pouvez obtenir quelque chose comme ce que vous demandez avec nc et canaux nommés, voir man mkfifo; ou cochez socat comme l'indique Alex Stragies.

Sans service de couche intermédiaire, les problèmes de base sont (1) que les données ne peuvent pas être écrites sur le réseau à moins qu'il y ait quelqu'un à l'autre bout qui les écoute, et (2) que les connexions TCP sont bidirectionnelles.

Étant donné que vous ne pouvez pas écrire de données sur le réseau à moins que quelqu'un ne les écoute, vous devez toujours démarrer l'écouteur avant vous pouvez envoyer des données. (Dans un système de transmission de messages, le processus de gestion des messages fournira une sorte de tampon.)

Votre exemple peut être facilement réécrit :

Commencez par démarrer un écouteur sur la machine2 (la destination) :
```
 nc -l 1234 | ...some processing with the received data...
```
Dans votre exemple, ce serait
```
 nc -l 1234 | cat
```
Cela bloquera et attendra que quelqu'un envoie des données au port 1234.
Ensuite, vous pouvez envoyer des données à partir de machine1 (la source) :
```
...make up some data... | nc machine2 1234
```
Dans votre exemple, ce serait
```
 echo "Hello" | nc machine2 1234
```

Si vous souhaitez traiter les données reçues d'une manière ou d'une autre et répondre, vous pouvez utiliser la fonction de cotraitement du shell. Par exemple, voici un serveur Web très simple (et très têtu) :

#! /bin/bash

while :; do
  coproc ncfd { nc -l 1234; }
  while :; do
    read line <&${ncfd[0]} || break
    line="$(
      echo "$line" |
      LC_ALL=C tr -cd ' -~'
    )"
    echo >&2 "Received: \"$line\""
    if [ "$line" = "" ]; then
      echo >&${ncfd[1]} "HTTP/1.0 200 OK"
      echo >&${ncfd[1]} "Content-Type: text/html"
      echo >&${ncfd[1]} "Connection: close"
      echo >&${ncfd[1]} ""
      echo >&${ncfd[1]} "<title>It works!</title>"
      echo >&${ncfd[1]} "<center><b>It works!</b></center>"
      echo >&${ncfd[1]} "<center>-- $(date +%Y-%m-%d\ %H:%M:%S) --</center>"
      break
    fi
  done
  kill %%
  sleep 0.1
done

Voyez comment la communication bidirectionnelle est réalisée entre le corps principal du script et le coprocess en utilisant les descripteurs de fichier dans le tableau $ncfd .

Si vous souhaitez simplement connecter deux ordinateurs à l'aide d'un programme de base comme nc, vous pouvez rediriger depuis/vers /dev/tcp/<host>/<port> .

Ce ne sont pas de vrais appareils mais une fiction créée par bash, donc des choses comme cat /dev/tcp/foo/19 ne fonctionnera pas, mais cat < /dev/tcp/foo/19 volonté.