Discussion :

[Maxime_Lambert]

Bonjour à tous,


Je me tourne vers vous, car je souhaite réaliser un module qui permet de créer un paquet réseau (TCP, ICMP, UDP, peu importe...) et qui l'enverrai sur le réseau, plus précisément sur mon interface lo.

J'ai fait pas mal de recherche, sans trouver vraiment une réponse satisfaisante.

Pour réaliser ce module, et travailler dans le noyau, j'utilise entre autre la bibliothèque skbuff.h et la structure struct sk_buff. J'utilise aussi la structure iphdr et (icmp|tcp|udp)hdr.

Je sais que pour réaliser ce module, je dois utiliser dans l'ordre les fonctions suivantes :

Code :

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

1
2
3
4
5
 
skb_alloc()
skb_reserve()
skb_put()
skb_push()

Mais j'ai du mal à voir la structure général du module. Comment appeler la fonction qui génèrera mon paquet ? Comment créer mon paquet avec les configurations que je désire (ajout de data, etc..). Et surtout, comment l'envoyer sur le réseau ?
J'ai vu parler de la fonction dev_queue_xmit(), mais je ne comprend vraiment pas comment l'utiliser, et où l'utiliser.

Je reste à votre disposition pour vous éclairer sur mon problème si besoin, et je pourrai également poster un code (demain) de ce que j'ai réalisé pour le moment si vous souhaitez.

Je vous remercie pour l'aide que vous pourrez m'apporter,

Bonne journée !

[imperio]

J'ai fait un projet scolaire portant sur les communications réseaux il y a peu de temps. Le code qui pourrait t'intéresser se trouve ici.

[Maxime_Lambert]

Salut,

Tout d'abord merci pour ta réponse.

Cependant, cela ne correspond pas tout à fait, puisque tu utilises des fonctions de "haut niveau". Mon but est de créer un paquet, en construisant moi-même les en-têtes de la couche transport, réseau et Ethernet.

Voici ce que j'ai pour le moment, mais je ne sais pas comment envoyer mon paquet sur le réseau. Ni savoir s'il est bien construit.

Code :

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

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
 
#include <linux/init.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/ip.h>
#include <net/ip.h>
 
void compute_udp_checksum(struct iphdr *pIph, unsigned short *ipPayload) {
  register unsigned long sum = 0;
  struct udphdr *udphdrp = (struct udphdr*)(ipPayload);
  unsigned short udpLen = htons(udphdrp->len);
 
  sum += (pIph->saddr>>16)&0xFFFF;
  sum += (pIph->saddr)&0xFFFF;
 
  sum += (pIph->daddr>>16)&0xFFFF;
  sum += (pIph->daddr)&0xFFFF;
 
  sum += htons(IPPROTO_UDP);
  sum += udphdrp->len;
 
  udphdrp->check = 0;
 
  while (udpLen > 1) {
    sum += * ipPayload++;
    udpLen -= 2;
  }
 
  if(udpLen > 0)
    sum += ((*ipPayload)&htons(0xFF00));
 
  while (sum>>16)
    sum = (sum & 0xffff) + (sum >> 16);
 
  sum = ~sum;
  udphdrp->check = ((unsigned short)sum == 0x0000)?0xFFFF:(unsigned short)sum;
}
 
static int temp_init(void)
{
    struct sk_buff *skb;
    struct iphdr *newip;
    struct udphdr *newudp;
 
    printk(KERN_INFO "temp: registering lkm...\n");
 
    /************************************ ALLOCATION *****************************************/
    printk(KERN_INFO "ALLOCATION\n");
    skb = alloc_skb(LL_MAX_HEADER + sizeof(struct iphdr*) + 0x08 + 0x00, GFP_ATOMIC); //LL + IP + UDP + DATA
 
	printk(KERN_INFO "Head : %s", skb->head);
	printk(KERN_INFO "Data : %s", skb->data);
	printk(KERN_INFO "Tail : %s", skb->tail);
	printk(KERN_INFO "End : %s", skb->end);
 
    if (skb_linearize(skb) < 0)
        return NF_DROP;
 
 
    /************************************ RESERVE ESPACE HEADER *****************************************/
	printk(KERN_INFO "RSERVE ESPACE HEADER\n");
    skb_reserve(skb, LL_MAX_HEADER);
    //skb_reserve sets the data pointer, and re-zeros the tail
    skb_reset_network_header(skb);
 
 
    /************************************ DATA *****************************************/
	printk(KERN_INFO "DATA\n");    
	u_char payload[] = "DATADATADATADATADATA";
    u32 payload_len = 20;
    unsigned char *data = skb_put(skb, payload_len);
    int err = 0;
    char __user *from;
 
    skb->csum = csum_and_copy_from_user( from, payload, payload_len, 0, &err);
    if(err) {
       printk(KERN_INFO "Erreur entrer data\n");
       return 0;
    }
 
    /************************************ UDP *****************************************/
    newudp = (void *)skb_push(skb, sizeof(struct udphdr));
    //skb_put re-sets the tail for udphdr
    newudp->source = 59046;
    newudp->dest   = 5001;
    newudp->len    = htons(sizeof(struct udphdr)); //1478
    newudp->check  = 0;
    //compute_udp_checksum(newip,data);
    printk(KERN_INFO "temp: newudp setup ...\n");
 
    /************************************ IP *****************************************/
    newip = (void *)skb_push(skb, sizeof(struct iphdr*));
    //skb_put sets the tail for iphdr
    newip->version  = 4;
    newip->ihl      = sizeof(struct iphdr) / 4;
    newip->tos      = 0;
    newip->id       = 0;
    newip->frag_off = htons(IP_DF);
    newip->protocol = IPPROTO_UDP;
    newip->check    = 0;
    newip->saddr    = 16777343;
    newip->daddr    = 16777343;
    printk(KERN_INFO "temp: newip setup ...\n");
 
    dev_queue_xmit(skb);
 
    kfree_skb(skb); // save the planet, recycle!
    printk(KERN_INFO "temp: lkm loaded.\n");
    return 0;
}
 
static void temp_exit(void)
{
    printk(KERN_INFO "temp: unregistering lkm...\n");
    printk(KERN_INFO "temp: unloaded lkm\n");
}
 
module_init(temp_init);
module_exit(temp_exit);
 
MODULE_LICENSE("GPL");

Si tu as une idée du comment faire, je suis preneur !

Merci, bonne journée

[imperio]

Navré, je ne suis pas allé aussi "bas", j'aurais pensé que regarder le code des fonctions kernel que j'ai utilisé aurait été suffisant (c'était comme ça que j'avais fait). Cela dit, j'ai l'impression que ce que tu souhaites faire est assez proche des raw sockets. Peut-être devrais-tu y jeter un coup d'oeil pour tenter ensuite de le porter en kernel ?

[Maxime_Lambert]

Salut,

J'ai regardé de ce côté là, mais je suis perdu

Code :

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

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
#include <linux/init.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/ip.h>
#include <net/ip.h>
#include <Create6.h>
 
void compute_udp_checksum(struct iphdr *pIph, unsigned short *ipPayload) {
    register unsigned long sum = 0;
    struct udphdr *udphdrp = (struct udphdr*)(ipPayload);
    unsigned short udpLen = htons(udphdrp->len);
 
    sum += (pIph->saddr>>16)&0xFFFF;
    sum += (pIph->saddr)&0xFFFF;
    sum += (pIph->daddr>>16)&0xFFFF;
    sum += (pIph->daddr)&0xFFFF;
    sum += htons(IPPROTO_UDP);
    sum += udphdrp->len;
    udphdrp->check = 0;
 
    while (udpLen > 1) {
        sum += * ipPayload++;
        udpLen -= 2;
    }
 
    if(udpLen > 0) {
        sum += ((*ipPayload)&htons(0xFF00));
    }
 
      while (sum>>16) {
          sum = (sum & 0xffff) + (sum >> 16);
      }
 
      sum = ~sum;
 
    udphdrp->check = ((unsigned short)sum == 0x0000)?0xFFFF:(unsigned short)sum;
}
 
void compute_ip_checksum(struct iphdr* iphdrp){
  iphdrp->check = 0;
  iphdrp->check = compute_checksum((unsigned short*)iphdrp, iphdrp->ihl<<2);
}
 
static unsigned short compute_checksum(unsigned short *addr, unsigned int count) {
  register unsigned long sum = 0;
  while (count > 1) {
    sum += * addr++;
    count -= 2;
  }
 
  if(count > 0) {
    sum += ((*addr)&htons(0xFF00));
  }
 
  while (sum>>16) {
      sum = (sum & 0xffff) + (sum >> 16);
  }
 
  sum = ~sum;
  return ((unsigned short)sum);
}
 
void aff_skb_info(struct sk_buff *skb){
	printk(KERN_INFO "Skb  : %x", (unsigned int) skb);
	printk(KERN_INFO "Head : %x", (unsigned int) skb->head);
	printk(KERN_INFO "Data : %x", (unsigned int) skb->data);
	printk(KERN_INFO "Tail : %x", (unsigned int) skb->tail);
	printk(KERN_INFO "End  : %x", (unsigned int) skb->end);
	printk(KERN_INFO "Mac header  : %x", (unsigned int) skb->mac_header);
	printk(KERN_INFO "Transport header  : %x", (unsigned int) skb->transport_header);
	printk(KERN_INFO "Network header  : %x", (unsigned int) skb->network_header);
}
 
static int temp_init(void)
{
    struct sk_buff *skb = NULL;
    struct iphdr *newip = NULL;
    struct udphdr *newudp = NULL;
    struct ethhdr *neweth = NULL;
	u_char *data_for = NULL;
	int i=0;
 
	printk(KERN_INFO "Create6 : Registering LKM...\n");
 
	/************************************ ALLOCATION *****************************************/
	printk(KERN_INFO " --------------------------------------  ALLOCATION -------------------------------------- \n");
	skb = alloc_skb(320,GFP_KERNEL);
	aff_skb_info(skb);
 
	/************************************ RESERVE ESPACE HEADER ****************************************/
	printk(KERN_INFO " --------------------------------------  RESERVE ESPACE HEADER -------------------------------------- \n");
  	skb_reserve(skb, 70);
	aff_skb_info(skb);
 
	/************************************ DATA ****************************************/
	printk(KERN_INFO " --------------------------------------  DATA -------------------------------------- \n");    
	u_char payload[] = "AAAAAAAAAA";
    	u32 payload_len = 10;
 
	skb_push(skb, payload_len);	
	memset(skb->data, 0, payload_len);
	memcpy(skb->data, payload, payload_len);
 
	aff_skb_info(skb);
	i=1;
	for(data_for = skb->data; data_for<skb->tail; data_for++ ){	
		printk(KERN_INFO "\tPayload %d\t: %.2x à l'adresse : %x", i, *data_for, (unsigned int) data_for);
		i++;
	}
 
	/************************************ UDP *****************************************/
  	printk(KERN_INFO " --------------------------------------  UDP -------------------------------------- \n");    
	skb->transport_header = (void *)skb_push(skb, sizeof(struct udphdr));
	memset(skb->data,0,sizeof(struct udphdr));
 
	newudp = skb->transport_header
    newudp->source = htons(59046);
   	newudp->dest   = htons(5001);
 	newudp->len    = htons(sizeof(struct udphdr));
 	newudp->check  = 0;
	newudp->check = csum_tcpudp_magic(in_aton("169.254.121.80"),in_aton("169.254.121.80"),sizeof(struct udphdr), IPPROTO_UDP,csum_partial(newudp, sizeof(struct udphdr), 0));
 
	aff_skb_info(skb);
	printk(KERN_INFO "Source Port : %x à l'adresse %x", newudp->source,&(newudp->source));
	printk(KERN_INFO "Dest Port : %x à l'adresse %x", newudp->dest,&(newudp->dest));
	printk(KERN_INFO "Len  : %x à l'adresse %x", newudp->len,&(newudp->len));
	printk(KERN_INFO "Check  : %x à l'adresse %x", newudp->check,(&newudp->check));
	i=1;
	for(data_for = skb->data; data_for<skb->tail; data_for++ ){	
		printk(KERN_INFO "\tPayload %d\t: %.2x à l'adresse : %x", i, *data_for, (unsigned int) data_for);
		i++;
	}
 
	/************************************ IP *****************************************/
  	printk(KERN_INFO " --------------------------------------  IP -------------------------------------- \n");  
	skb->network_header = (void *)skb_push(skb, sizeof(struct iphdr));
	memset(skb->data,0,sizeof(struct iphdr));
 
	newip = skb->network_header
	newip->version  = 4;
	newip->ihl      = 4;
	newip->tos      = 0;
	newip->id       = 0;
	newip->frag_off = 0;
	newip->ttl = 64;
	newip->protocol = IPPROTO_UDP;
	newip->saddr    = in_aton("169.254.121.80");
 	newip->daddr    = in_aton("169.254.121.80");
	newip->check    = 0;
	compute_ip_checksum(newip);
 
	aff_skb_info(skb);
	printk(KERN_INFO "\n");	
	printk(KERN_INFO "Version  : %x", newip->version);
	printk(KERN_INFO "Ihl  : %x", newip->ihl);
	printk(KERN_INFO "TOS  : %x à l'adresse %x", newip->tos,&(newip->tos));
	printk(KERN_INFO "ID  : %x à l'adresse %x", newip->id,(&newip->id));
	printk(KERN_INFO "Frag Off  : %x à l'adresse %x", newip->frag_off,&(newip->frag_off));
	printk(KERN_INFO "TTL  : %x à l'adresse %x", newip->ttl,&(newip->ttl));
	printk(KERN_INFO "Protocol  : %x à l'adresse %x", newip->protocol,&(newip->protocol));
	printk(KERN_INFO "Source @  : %x à l'adresse %x", newip->saddr,&(newip->saddr));
	printk(KERN_INFO "Destination @  : %x à l'adresse %x", newip->daddr,&(newip->daddr));
	printk(KERN_INFO "Check IP : %x à l'adresse %x", newip->check,&(newip->check));
	i=1;
	for(data_for = skb->data; data_for<skb->tail; data_for++ ){	
		printk(KERN_INFO "\tPayload %d\t: %.2x à l'adresse : %x", i, *data_for, (unsigned int) data_for);
		i++;
	}
 
	/************************************ ETHERNET *****************************************/
  	printk(KERN_INFO " --------------------------------------  ETHERNET -------------------------------------- \n");    
	skb->mac_header = (void *)skb_push(skb, sizeof(struct ethhdr));
	memset(skb->data,0,sizeof(struct ethhdr));
 
	neweth = skb->mac_header;
	neweth->h_dest[0] = 0x04;neweth->h_dest[1] = 0x7d;neweth->h_dest[2] = 0x7b;neweth->h_dest[3] = 0x4d;neweth->h_dest[4] = 0xa8;neweth->h_dest[5] = 0x75;
	neweth->h_source[0] = 0x04;neweth->h_source[1] = 0x7d;neweth->h_source[2] = 0x7b;neweth->h_source[3] = 0x4d;neweth->h_source[4] = 0xa8;neweth->h_source[5] = 0x75;
	neweth->h_proto = ETH_P_IP;
 
	aff_skb_info(skb);
	printk(KERN_INFO "\n");	
	printk(KERN_INFO "MAC Destination : %x", neweth->h_dest);
	printk(KERN_INFO "MAC Source : %x", neweth->h_source);
	printk(KERN_INFO "Protocole : %x à l'adresse %x", neweth->h_proto);
	i=1;
	for(data_for = skb->data; data_for<skb->tail; data_for++ ){	
		printk(KERN_INFO "\tPayload %d\t: %.2x à l'adresse : %x", i, *data_for, (unsigned int) data_for);
		i++;
	}
 
	dev_queue_xmit(skb);
 
	kfree_skb(skb);
	printk(KERN_INFO "\nCreate7 : LKM loaded.\n");
	return 0;
}
 
static void temp_exit(void)
{
    printk(KERN_INFO "Create7 : Unregistering LKM...\n");
    printk(KERN_INFO "Create7:  Unloaded LKM\n");
}
 
module_init(temp_init);
module_exit(temp_exit);

Pour le moment j'ai ce code (ci dessus). Il log dans /var/log/kern.log les informations relatifs aux adresses et valeurs contenues dans ma structure skb. Elles semblent correctes.

Mais j'ai vu sur internet, qu'il fallait définir une structure net_device, rattaché à la structure sk_buff (skb->dev dans mon cas). Cependant impossible de trouver comment remplir correctement la structure net_device.

Ensuite, il faudrait appeler une, ou plusieurs, des fonctions suivantes :

Code :

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

1
2
hard_start_xmit(skb, dev)
dev_queue_xmit(skb)

Mais lorsque c'est le cas, j'ai kernel panic/oops.

Je ne sais pas comment faire :/

Merci pour votre aide

[sambia39]

Bonsoir

Création d'un paquet dans le noyau Linux et envoie sur le réseau

On ne crée pas un paquet dans le noyau LINUX mais l'on crée des paquets pour qu'il soit manipulés par un gestionnaires (modules chargeable ici dans le cas réseaux) qui n'est pas indispensable au fonctionnement du noyau Linux.
L'architecture ou la charpente du système Linux est ajustable c'est-à-dire qu'autour du noyau Linux en peut soit charger ou décharger (monté /démonté) des modules (dits des modules chargeables) et un module n'est rien d'autre qu'un gestionnaire ( de périphérique, fichier, etc..) et dans le cas présent en parle du gestionnaire réseau ou module réseaux et pour être plus précis dans votre cas une manipulation des paquets au niveau du pilote réseaux de la carte réseaux.

Salut,
Cependant, cela ne correspond pas tout à fait, puisque vous utilisé des fonctions de "haut niveau". Mon but est de créer un paquet, en construisant moi-même les en-têtes de la couche transport, réseau et Ethernet.

d'une certaine manière (je doute) toutes les manipulations dont vous faite sont fait aux niveaux le plus haut du module.

Bonjour à tous,
Je me tourne vers vous, car je souhaite réaliser un module qui permet de créer un paquet réseau (TCP, ICMP, UDP, peu importe...) et qui l'enverrai sur le réseau, plus précisément sur mon interface lo.

Réaliser un module qui permet de créer des paquets moi je comprends créer un pilote réseau qui manipule les trames ( paquet) ce qui différents de

Mon but est de créer un paquet, en construisant moi-même les en-têtes de la couche transport, réseau et Ethernet.

Je sais que pour réaliser ce module, je dois utiliser dans l'ordre les fonctions suivantes :

Code :

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

1
2
3
4
5
 
skb_alloc() 
skb_reserve()
skb_put()
skb_push()

Mais j'ai du mal à voir (1)la structure général du module. (2)Comment appeler la fonction qui génèrera mon paquet ? (3)Comment créer mon paquet avec les configurations que je désire (ajout de data, etc..). Et surtout, comment l'envoyer sur le réseau ?
J'ai vu parler de la fonction dev_queue_xmit(), mais je ne comprend vraiment pas comment l'utiliser, et où l'utiliser.
Je reste à votre disposition pour vous éclairer sur mon problème si besoin, et je pourrai également poster un code (demain) de ce que j'ai réalisé pour le moment si vous souhaitez.
Je vous remercie pour l'aide que vous pourrez m'apporter,
Bonne journée !

Certaines choses sont des peu vagues je vais tenter de faire de mon mieux pour vous apporter certaines informations.
Commençons depuis le début mis à par une légère confusion entre module et création d'entête de paquet l'architecture d'un pilote réseau se présente sous cette forme

(1)Structure générale du module
Pile Réseaux <-> Pilote réseaux <-> bus ( PCI,USB )
La pile réseaux se charge des différents protocoles c'est un peut la partie haute du module qui permet de définir les trames , protocole etc.. et elle est totalement indépendante de la carte réseaux.
la partie pilote réseau est la passerelle c'est elle qui fait le lien entre la pile réseaux et le bus utiliser pour l'émission ou la réception des paquets.
la partie bus quant à elle correspond à l'interface matérielle du périphérique USB ou PCI.
Comment tout cela fonctionne en résumer ? : Toutes les données utilisateur sont transmis aux pilotes réseaux et ensuite celle-ci les transmet à son tour au bus. L'opération inverse fait appel à une interruption matérielle lors de la réception des paquets (sans trop aller en détaille) et la fonction bas niveaux de traitement des donnée fait remonter l'ensemble à la pile réseaux pour qu'elle puisse faire sont job.

(2)Comment appeler la fonction qui génèrera mon paquet ?
je dirais qu'il faut non pas générer les paquets à la volée mais les concevoir en fonction des différentes actions que vous allez faire au niveau du bus utiliser.

(3)Comment créer mon paquet avec les configurations que je désire (ajout de data, etc..)
Pour créer un paquet vous allez devoir utiliser une structure que vous sembler connaitre qui est sk_buff de vrai non socket buffer la pièce maitresse de la pile réseaux et cette structure n'êtes rien d'autre une liste doublement chainée avec les champs important qui sont: data , head, tstamp etc..

Salut,
......
Pour le moment j'ai ce code (ci dessus). Il log dans /var/log/kern.log les informations relatifs aux adresses et valeurs contenues dans ma structure skb. Elles semblent correctes. // ??
Mais j'ai vu sur internet, qu'il fallait définir une structure net_device, rattaché à la structure sk_buff (skb->dev dans mon cas). Cependant impossible de trouver comment remplir correctement la structure net_device.
Ensuite, il faudrait appeler une, ou plusieurs, des fonctions suivantes :

Code :

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

1
2
hard_start_xmit(skb, dev)
dev_queue_xmit(skb)

Mais lorsque c'est le cas, j'ai kernel panic/oops.
Je ne sais pas comment faire :/
Merci pour votre aide

C'est normale qu'il utilise Une Telle structure car elle faites pour représenter le matériel ( périphérique réseau) et il faut allouer et l'initialiser avec les bonnes informations.

Code :

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

1
2
hard_start_xmit(skb, dev)
dev_queue_xmit(skb)

[/B]

Code :

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

hard_start_xmit(skb, dev)

[/B]est une fonction d'envoi de la trame son contenue dépend de ce que le développeur a implanté et peut exister sous des prototype comme

Code :

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

supercartex_start_xmit( struct sk_buff *ptr_skb, struct net_device *ptr_device)

J'avoue avoir survolé votre code source et vue les commentaires j'aimerais savoir si le code sources dont vous avez poster est tirée de la conception d'un module réseaux ? si oui, quel est le type de mode ( caractère / bloc )
et quelles sont vos intentions voulez-vous créer un pilote réseau où juste crée une trame de données à votre façon ?
à bientôt