Problème avec IPPROTO

Version imprimable

Voici mon problème:
Je voudrais envoyer un paquet IP de type ICMP-EHO (un ping quoi) par le biais d'une socket raw qui me permettra de spécifier
l'en-tête IP à utiliser (Je ne voudrais pas que le protoole IP me génère une en-tête IP). Pour cela j'ai lu dans le man SOCK_RAW qu'il faut actier l'option IP_HDRINCL pour povoir soi-même spécifier son en-tête IP et que cette option est directementactivée lorsqu'on utilise le protocole IPPROTO_RAW dans la fontion soket (sous linux). Je crée donc ma socket

Code:

1
2
3
4
 
 // CrÃ©ation de la soket
 sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
 if(sock == -1) { printf("Erreur de crÃ©ation de la socket\n%s\n", strerror(errno)); return -1; }

j'ai des structures IP_HDR et ICMP_HDR_ECHO déclarées ainsi

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
#ifndef __STRUCTURES_H__
#define __STRUCTURES_H__
 
typedef unsigned char u_char;
typedef signed char s_char;
typedef unsigned short u_short;
typedef signed short s_short;
typedef signed int s_int;
typedef unsigned int u_int;
typedef unsigned long u_long;
 
 
// En-tÃªte IP
typedef struct iphdr {
 
 #if defined(__LITTLE_ENDIAN_BITFIELD)
  u_int ihl:4; // Longueur d'en-tÃªte
  u_int version:4; // version
 #else
  u_char version:4; // version
  u_int ihl:4; // longueur d'en-tÃªte
 #endif
 
 u_char tos:8; // Type de service
 u_short tot_len:16; // Longueur totale du datagramme
 u_short id:16; // Identificateur du datagramme
 u_short frag_off:16; // Offset du fragment
 u_char ttl:8; // Temps de vie
 u_char protocol:8; // Protocol Internet utilisÃ©
 u_short check:16; // Champ de contrÃ´le (checksum)
 u_int saddr:32; // Adresse source
 u_int daddr:32; // Adresse destination
 /*The options start here. */
} IP_HDR;
 
 
// Structure de l'en-tÃªte ICMP
typedef struct icmphdr_echo {
 u_char type:8; // Type de message ICMP
 u_char code:8; // Code du message ICMP
 u_short checksum:16; // Checksum
 u_short id:16; // Identificateur
 u_short sequence:16; // NumÃ©ro de sÃ©quence
 u_long  timestamp;
} ICMP_HDR_ECHO;
 
#endif

Ma méthode consiste don à créer un tampon d'envoi dont la taille est la somme de la taille de l'en-tête IP et ICMP, je rempli ce tampon, je l'envoi par sendto et j'attends la réponse du destinataire. voici mon ode

D'abord la fontion de remplissage de l'en-tête ICMP

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
void MakeICMPECHO(char* sendbuf, int paquetId){
 
 ICMP_HDR_ECHO* icmp = (ICMP_HDR_ECHO*)sendbuf;
 
  // Remplissage icmphdr_echo
 memset(sendbuf, 0, sizeof(ICMP_HDR_ECHO));
 icmp->type = 8; // RequÃªte ICMP de type echo
 icmp->code = 0;
 icmp->checksum = 0;
 icmp->id = 0;
 icmp->sequence = 0;
 icmp->timestamp = 100000;
 
 // Mise en place des Checksum
 icmp->checksum = CheckSum((unsigned short *)sendbuf, sizeof(ICMP_HDR_ECHO));
}

Ensuite celle de remplissge du tampon de IP

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
void MakeIPICMP(char* sendbuf, int paquetId, char* s, char* d){
 
 IP_HDR* ip = (IP_HDR*)sendbuf;
 
 // Remplissage ip
 memset(sendbuf, 0, sizeof(IP_HDR));
 ip->ihl = sizeof(IP_HDR);
 ip->version = 4;
 ip->tos = 0;
 ip->tot_len = sizeof(IP_HDR) + sizeof(ICMP_HDR_ECHO);
 ip->id = paquetId;
 ip->frag_off = (u_short)(ip + ip->ihl);
 ip->check = 0;
 ip->protocol = 1;
 ip->saddr = htonl(inet_addr(s));
 ip->daddr = htonl(inet_ntoa(d));
 
 // Mise en place des Checksum
 ip->check = CheckSum((unsigned short *)sendbuf, sizeof(IP_HDR));
}

enfin le programme principal

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
int main(int argc, char* argv[]){
 
 // DÃ©claration des variables utiles
 int sock;  // La raw socket
 int send, recieve; // statut d'envoi et de reception
 char sendbuficmp[sizeof(ICMP_HDR_ECHO)]; // Buffer icmp
 char sendbufip[sizeof(IP_HDR)]; // Buffer IP
 char sendbuf[sizeof(IP_HDR) + sizeof(ICMP_HDR_ECHO)];
 char* ptr; // UtilisÃ© pour la copie des en-tÃªte dans le tampon d'enoi sendbuf
 char recvbuf[MAX_PACKET]; // Buffer de reception
 struct icmphdr_echo* icmp; // En-tÃªte icmp de type echo
 struct iphdr* ip; // En-tÃªte ip
 struct icmphdr_echo* ricmp; // En-tÃªte icmp de retour
 struct iphdr* rip; // En-tÃªte ip de retour
 char* csource = argv[1]; // @ source
 char* cdest = argv[2]; // @ destination du datagramme
 char* cproxy = argv[3]; //  du proxy
 
 struct sockaddr_in dest, from; // Adresse du destinataire
 fd_set fdsr; // Ensemle surveillÃ©
 struct timeval tv_timeout; // DÃ©lai de sureillance
 int surv, fromlen = sizeof(from);
 
 
 // CrÃ©ation de la soket
 sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
 if(sock == -1) { printf("Erreur de crÃ©ation de la socket\n%s\n", strerror(errno)); return -1; }
 // PrÃ©paration du paquet ICMP
 MakeICMPECHO(sendbuficmp, getpid());
 MakeIPICMP(sendbufip, getpid(), csource, cdest);
 
 // Initialisation du tampon d'envoi Ã  0
 memset(sendbuf, 0, sizeof(IP_HDR) + sizeof(ICMP_HDR_ECHO));
 
 // ptr pointe sur sendbuf
 ptr = sendbuf;
 
 // Copie de l'en-tÃªte IP dans ce tampon
 memcpy(ptr, sendbufip, sizeof(IP_HDR));
 
 // On va en fin d'en-tÃªte IP
 ptr += sizeof(IP_HDR);
 
 // Copie de l'en-tÃªte ICMP  la suite dans le tampon (en partie donnÃ©es du datagramme IP)
 memcpy(ptr, sendbuficmp, sizeof(ICMP_HDR_ECHO));
 
 // ParamÃ©trage de l'adresse d'envoi direct
 dest.sin_family = AF_INET;
 dest.sin_addr.s_addr = inet_addr(cproxy);
 
 // Envoi du message
 send = sendto(sock, sendbuf, sizeof(IP_HDR) + sizeof(ICMP_HDR_ECHO), 0, (struct sockaddr *)&dest, sizeof(struct sockaddr_in));
 if(send == -1) { printf("Erreur d'envoi\n%s\n", strerror(errno)); return -1; }
 
 // ParamÃ©trage de l'ensemble surveillÃ©
 FD_ZERO(&fdsr);
 FD_SET(sock, &fdsr);
 tv_timeout.tv_sec = 5;
 tv_timeout.tv_usec = 0;
 
 // Appel de la fontion de surveillane
 surv = select(sock + 1, &fdsr, NULL, NULL, &tv_timeout);
 if(surv > 0 ){
  if (FD_ISSET(sock, &fdsr)){
   printf("DonnÃ©es en entrÃ©es sur la socket\n");
   recieve = recvfrom(sock, recvbuf, MAX_PACKET, 0, (struct sockaddr *)&from, &fromlen);
   decode_recv(recvbuf);
  }
 }
 else{
  printf("Aucune DonnÃ©es en entrÃ©es sur la socket\n");
 }
 return 0;
}

j'apelle l'éxécutable avec

Code:

1
2
 
./sockraw2 @source @dest @passerelle

mais malheureusement le destinataire ne répond pas et je sais pas pourquoi. Je me demande si mes en-tête sont bonnes ou si je rempli correctement les en-têtes ou encore si le message arrive à bon port.

14/03/2008, 14h59
valefor

Je te conseille d'utiliser un programme de surveillance réseau :
- wireshark (ex-ethereal) : j'aime beaucoup
- tcpdump : j'ai pas trop utilisé

Tu verras donc ce qui circule et tu ne te demanderas plus si tes entêtes sont bonnes.

Ensuite, il est conseillé dans le man de socket raw d'utiliser plutôt libpcap pour des soucis de portabilité. Fait des essais avec cela en plus.
15/03/2008, 09h00
yashiro

Ca sera difficile pour moi d'utiliser un code déja fait comme wireshark ou ethereal vu que c'est dans le cadre d'un projet académique et l'encadreur veut qu'on écrive un programme capable d'envoyer nos propres paquets sur le réseaux. Donc mon problème rteste entier quant à savoir pourquoi le destinataire ne répond pas
16/03/2008, 13h02
corrector
Citation:

Envoyé par yashiro

Ca sera difficile pour moi d'utiliser un code déja fait comme wireshark ou ethereal vu que c'est dans le cadre d'un projet académique et l'encadreur veut qu'on écrive un programme capable d'envoyer nos propres paquets sur le réseaux. Donc mon problème rteste entier quant à savoir pourquoi le destinataire ne répond pas

Teste ton programme avec tcpdump pour vérifier que

Dans un terminal tu lances "tcpdump -i lo" (bien sûr il faut être root - enfin, avoir CAP_machin_bidule).

Si il y a déjà de l'activité sur ta machine en local, ça risque d'être verbeux et tu aura du mal à faire le trie. Dans ce cas, essaie "tcpdump -i lo icmp".

Dans un autre terminal fais "ping localhost", "ping une-adresse-locale" pour comprendre la sortie de tcpdump.

Après tu lances ton programme, et tu observes les paquets dans tcpdump. Si tu ne vois pas la même chose qu'avec ping, c'est que ton programme a un bug!
Citation:
Envoyé par yashiro

Pour cela j'ai lu dans le man SOCK_RAW qu'il faut actier l'option IP_HDRINCL pour povoir soi-même spécifier son en-tête IP et que cette option est directementactivée lorsqu'on utilise le protocole IPPROTO_RAW dans la fontion soket (sous linux). Je crée donc ma socket

Code:

1 2 3 // Création de la soket sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
Il fallait lire le man entièrement :

Citation:

Envoyé par man sock_raw

An IPPROTO_RAW socket is send only.

Citation:
Envoyé par yashiro
Code:

1 2 3 4 void MakeIPICMP(... char* s, char* d){ ... ip->saddr = htonl(inet_addr(s)); ip->daddr = htonl(inet_ntoa(d));
Tu es sûr que tu as réellement ça dans ton programme?
Citation:
Envoyé par yashiro
Code:

1 2 3 4 5 6 7 8 9 10 11 12 char* csource = argv[1]; // @ source char* cdest = argv[2]; // @ destination du datagramme char* cproxy = argv[3]; // du proxy ... MakeIPICMP(... csource, cdest); ... // ParamÃ©trage de l'adresse d'envoi direct dest.sin_family = AF_INET; dest.sin_addr.s_addr = inet_addr(cproxy); // Envoi du message send = sendto(sock, sendbuf, sizeof(IP_HDR) + sizeof(ICMP_HDR_ECHO), 0, (struct sockaddr *)&dest, sizeof(struct sockaddr_in));
Je n'ai pas trouvé de doc et je n'ai jamais fais ça, mais intuitivement j'aurai utilisé send plutôt que sendto.

Quel doc indique qu'il faut utiliser sendto?
Citation:
Envoyé par yashiro
j'apelle l'éxécutable avec
Code:

1 2 ./sockraw2 @source @dest @passerelle
Je ne comprends pas cette histoire de passerelle. Pourquoi tu t'occupes de ça?

(Aussi, attention au jeu de caractères quand tu postes : c'est de l'UTF-8?)

19/03/2008, 14h24
yashiro

Le problème c'est que sendto s'utilise avec des socket de type stream (orientées connexion) qu'on peut créer en spécifiant le type SOCK_STREAM au lieu de SOCK_RAW.
20/03/2008, 09h06
corrector

Citation:

Envoyé par yashiro

Le problème c'est que [send] s'utilise avec des socket de type stream (orientées connexion) qu'on peut créer en spécifiant le type SOCK_STREAM au lieu de SOCK_RAW.

(J'ai corrigé le "sendto"!)

Non, en fait send s'utilise avec des socket connectées, ce qui n'est effectivement pas le cas ici.

(J'avais tord de penser que send irait chercher l'adresse dans le message lui-même.)

Je ne comprends toujours pas dans quel cas tu voudrais passer à sendto une adresse différente de l'adresse destination de ton message. Pourquoi parles-tu de "passerelle"?