Discussion :

[m.schambion]

Bonjour à tous,

après de longues recherches sur ce forum et sur d'autres, je n'ai pas pu trouvé mon bonheur, voilà pourquoi j'ouvre une nouvelle discussion.
Je suis débutant en programmation réseau et j'ai besoin de votre aide pour la création d'une tunnel HTTP IPV4 pour IPv6.

Voilà en gros le processus:
1. A veut envoyer un paquet ipv6 vers B mais le réseau de A ne laisse pas passer ces paquets.
2. Donc A construit le paquet Ipv6, puis encapsule ce paquet dans un paquet http qu’il envoie vers une machine C en IPv4.
3. C extrait le paquet IPv6 et l’envoie vers B en indiquant sa propre adresse source.

Mon problème est dans le fait d'encapsuler un paquet dans un autre et ensuite de l'extraire à nouveau coté serveur.

Merci de m'aiguiller.

Mathieu.

[m.schambion]

J'ai surement oublié des détails techniques.

Actuellement mon client crée une socket avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

socket(AF_INET, SOCK_STREAM, IPPROTO_RAW);

et en modifie ensuite l'entête :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

setsockopt(s,IPPROTO_IP,IP_HDRINCL,(char*)&x,sizeof(x))<0);

Enfin j'essaie de créer un paquet de la manière suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
unsigned char packet[4098];
        struct iphdr   *ip;				//l'entête IP de destination
        struct icmphdr *icmp;			//l'entête ICMP du paquet
        struct iphdr   *origip;		//l'entête IP source
        unsigned char  *data;			//les données du paquet
        int i;
 
 
        ip = (struct iphdr *)packet;
        icmp = (struct icmphdr *)(packet+IPHDRSIZE);
        origip = (struct iphdr *)(packet+IPHDRSIZE+ICMPHDRSIZE);
        data = (char *)(packet+IPHDRSIZE+IPHDRSIZE+ICMPHDRSIZE);

Je précise ensuite la version IP dans la structure ip et origip, ainsi que le protocol.

Mais comment réellement encapsuler un paquet IPv6 dans un IPv4 et ensuite de l'extraire à nouveau coté serveur ?

[gangsoleil]

Bonjour,

L'idée de base est la suivante :

• Forger un paquet IPv6 entier -- qui se compose donc de l'en-tête IP et de la payload.
• Forger un paquet IPv4 qui se compose de l'entête et de la payload, qui est le paquet IPv6 complet.

Où se situe ton problème exactement ?

Si tu ne veux pas gérer les paquets IPv4 à la main, tu traites ton flux de paquets IPv6 comme n'importe quel trafic à envoyer.

Ça devrait te suffir pour envoyer les paquets, et les recevoir de l'autre côté. Bon, après, il te faut encore faire le logiciel de routage sur B (enfin si j'ai bien compris le rôle de B).

[m.schambion]

Tout d'abord merci d'avoir pris le temps de me répondre.

En fait, au niveau de la théorie sur le principe d'encapsulation et les sockets c'est plus au moins ok.
Par contre ce qui me pose problème c'est de réaliser tout ça en C.

Pour la création de la socket je pense que c'est bon, je peux créer une socket TCP de la manière suivante, non?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int s = socket(AF_INET, SOCK_STREAM, IPPROTO_RAW);

Ensuite dois-je lui affecter l'option IP_HDRINCL pour pouvoir modifier l'entête IP?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

setsockopt(s,IPPROTO_IP,IP_HDRINCL,(char*)&x,sizeof(x))

Par contre pour ce qui est de la création des paquets IPV4 et IPv6, j'ai du mal...
J'ai trouvé des choses sur le forum et sur d'autres sites mais j'ai du mal à comprendre comment procéder.

[gangsoleil]

Par contre pour ce qui est de la création des paquets IPV4 et IPv6, j'ai du mal...
J'ai trouvé des choses sur le forum et sur d'autres sites mais j'ai du mal à comprendre comment procéder.

Je pense qu'il faut que tu te renseignes sur les RAW socket : une fois qu'une telle socket est établie, tu peux émettre ce que tu veux dessus, dont des paquets IPv4 (qui contiendront des paquets IPv6 en l'occurence, mais peu importe).

[m.schambion]

Encore merci pour tes infos.
J'ai continué mes recherches depuis mon dernier post.

Voilà comment je compte créer mon paquet IPv6:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
unsigned char packet_ipv6[4098];
struct iphdr   *ip_ipv6;				//l'entête IP de destination
struct iphdr   *origip_ipv6;		        //l'entête IP source
unsigned char  *data_ipv6;			//les données du paquet IPv6
 
ip_ipv6 = (struct iphdr *)packet_ipv6;
origip_ipv6 = (struct iphdr *)(packet_ipv6+IPHDRSIZE);
data_ipv6 = (char *)(packet_ipv6+IPHDRSIZE+IPHDRSIZE);

Et mon paquet IPv4 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
unsigned char packet_ipv4[4098];
struct iphdr   *ip_ipv4;				                        //l'entête IP de destination
struct iphdr   *origip_ipv4;		                                //l'entête IP source
unsigned char  *packet_ipv6_into_ipv4;			        //le paquet IPV6
 
ip_ipv4 = (struct iphdr *)packet_ipv4;
origip_ipv4= (struct iphdr *)(packet_ipv4+IPHDRSIZE);
packet_ipv6_into_ipv4= (char *)(packet_ipv4+IPHDRSIZE+IPHDRSIZE);

Et donc par la suite, une fois que j'aurais modifié les différentes entêtes avec notamment ip->version = 4 ou 6, j'affecte le paquet IPv6 dans les données du IPv4:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*((unsigned char *)data_ipv4) = packet_ipv6;

Tu penses que c'est ok?

[gangsoleil]

En regardant rapidement ton code, on voit que tu fais des paquets de 4K. Y-a-t'il une raison spécifique ?

Si je te demande ça, c'est parce que si ton paquet IP est émis sur ethernet, il y a de fortes chances pour que la taille d'un paquet soit limité au plus à 1500 octets (sauf jumbo-frames et MTU spécifique, mais ça serait suprenant), à moins que tu n'utilises autre chose (genre infiniband en IPoIB, mais dans ce cas on peut se demander pourquoi utiliser IP).

Et si tu es limité à 1500 octets et que tu émets des paquets de 4K, je pense qu'ils vont se faire jeter.


À mon sens, le problème vient du concept "1 paquet IPv6 devient 1 paquet IPv4", alors qu'on peut aussi le concevoir de la manière suivante : j'ai des données ordonnées à émettre (en l'occurence des paquets IPv6, mais ça serait (presque) pareil si c'étaient des patates), donc je fais la boucle suivante :
ouvrir socket ipv4
tant que j'ai des données
send data
fin tant que

Et de l'autre côté, tu reçois "normalement" tes data, que tu réassembles (le protocole t'assurant l'ordre), et que tu peux ré-emettre en RAW (du moins en théorie).

[Matt_Houston]

Et si tu es limité à 1500 octets et que tu émets des paquets de 4K, je pense qu'ils vont se faire jeter.

Plus probablement se faire fragmenter, sauf si ce sont de véritables RAW sockets (mais pourquoi y recourir pour au final construire un header IP parfaitement légal ?).

[BufferBob]

(...) de véritables RAW sockets (mais pourquoi y recourir pour au final construire un header IP parfaitement légal ?).

c'est pas faux, sauf erreur le principe ce serait d'arriver à set le champ next_header du paquet ipv6 à IPPROTO_IP, je sais pas si c'est faisable directement sans avoir recours aux raw sockets
Edit: bon en fait j'avais compris à l'envers (4in6), en revanche il semble qu'il y a plusieurs techniques de tunneling (6in4, 6to4, 6over4, Teredo...), à mon avis il faudrait plus de précisions ici quant au type de tunnel que le PO cherche à mettre en place

par contre des considérations plus globales au projet, j'imagine que le but c'est de se positionner en ~routeur~ (broker) un moment donné, donc de capturer les trafic du tunnel ipv6 ipv4 sur une interface pour dés-encapsuler et rebalancer les paquets ipv4 ipv6 sur une autre interface (ou alors le propos est d'envoyer un unique paquet ? ), pour moi ce serait le job d'un driver ça, donc plutôt d'un module noyau que d'un programme userland, je sais pas si ça doit entrer en considération ?
en fait dans le cas d'un tunnel automatique il est possible qu'il n'y ait besoin d'écrire que la partie client, la désencapsulation pouvant être réalisée automatiquement donc par la pile noyau déjà existante

[gangsoleil]

Plus probablement se faire fragmenter, sauf si ce sont de véritables RAW sockets (mais pourquoi y recourir pour au final construire un header IP parfaitement légal ?).

Il est bien question de RAW sockets ici, c'est pour ca que je parle de rejet.

Et la fragmentation n'existant de toute maniere plus en IPv6, il y a aussi un potentiel probleme lors de la re-emission.

[BufferBob]

Il est bien question de RAW sockets ici

pour quelle(s) raison(s) ?

[gangsoleil]

pour quelle(s) raison(s) ?

Parce que j'ai lu le code trop vite et en diagonal, et que j'ai interprete le IPPROTO_RAW de socket(AF_INET, SOCK_STREAM, IPPROTO_RAW); comme SOCK_RAW.

Donc du coup merci de ta remarque

[BufferBob]

j'ai interprete le IPPROTO_RAW de socket(AF_INET, SOCK_STREAM, IPPROTO_RAW); comme SOCK_RAW.

ok ! mais de toutes façons son code n'est possiblement pas valide puisqu'il n'y arrive pas

le sujet est super intéressant de mon point de vue, mais je persiste à penser qu'il manque un certain nombre de choses à préciser avant de coder quoique ce soit