Modification de noyau Résolu/Fermé

Question

Bonjour,
Je suis actuellement en première année de mon Bachelor en informatique à Bâle, et j'aurai besoin d'aide pour un devoir supplémentaire qui me permettrait de valider mon semestre, au vu de mes résultats pourtant bons mais insuffisants (70% sur 75% requis). Je dois donc le faire en allemand (puisque c'est la langue officielle de l'université). Il faut que je finisse le devoir (dont ce n'est qu'une partie) pour le 26 janvier.
Il s'agit de modifier le Linux-Kernel de ma machine virtuelle, de façon à ce que chaque paquet IP rentrant soit enregistré dans le Kernel-Log.
En furetant sur le net, et avec mes maigres connaissances, je pense avoir compris qu'il me faudra modifier un .config File dans /usr/src/linux-headers-2.6.31-14-generic.
(Après, reste encore à savoir pourquoi je dispose de linux-headers-2.6.31-14-generic de linux-headers-2.6.31-14 en même temps...)

Y-a-t-il quelqu'un qui pourrait me briefer sur le problème ?
Merci beaucoup.
Arthur


PS: ma machine virtuelle tourne sur VMWare, si cela entre en ligne de jeu...

mamiemando · Answer

Un noyau c'est quoi ?

En fait, un kernel (noyau) est la couche logicielle qui permet d'interfacer ton OS (operating system, système d'exploitation) avec ton matériel. Tu peux le voir comme une espèce de gros driver. Le kernel gère typiquement
- ton matériel (disque dur, clavier, carte réseau...) et la connectique (usb, ide, sata...),
- les systèmes de fichiers (ext2, ext3, reiserfs, vfat...),
- les protocoles réseaux "bas niveau" (udp, tcp, ip...) : manifestement la partie qui t'intéresse ;-)
- etc...

La notion entre noyau et OS est assez peu perceptible sous windows (on lance "windows") mais ce n'est pas du tout le cas sous linux. Un même OS linux (mettons une ubuntu) peut-être lancé par le biais de plusieurs noyaux. On peut d'ailleurs lancer un kernel donné avec un jeu d'option variable, et c'est ce qui distingue un noyau lancé normalement d'un noyau lancé en "recovery mode", comme le montre cette capture d'écran :
http://yekubuntu.free.fr/hoary/images/grub.jpeg

Sous linux, le menu qui permet de choisir avec quel noyau démarrer (que ce soit un kernel linux ou autre) et avec quel jeu d'option s'appelle un boot loader. Il existe deux boot loader disponibles sous linux, chacun ayant ses avantages : grub et lilo :
http://doc.ubuntu-fr.org/lilo
http://doc.ubuntu-fr.org/grub-pc?redirect=1

Sous linux, les noyaux sont généralement rangés dans /boot.

Sous debian, il s'agit pour la plupart des utilisateur de noyaux précompilés par les mainteneurs debian et installé au travers des paquets linux-image-... . Les autres distributions suivent souvent la même approche (à savoir fournir des noyaux tout prêts sous forme de paquet afin d'épargner à l'utilisateur une compilation de noyau, souvent longue et fastidieuse).

Ceci dit rien n'empêche de compiler son propre noyau en téléchargeant des sources par exemple sur kernel.org, et ce quelle que soit la distribution. On peut alors soit passer par le makefile fourni dans l'archive ainsi téléchargée, soit sous debian (et distributions dérivées) utiliser make-kpkg.

Les versions de noyau

On distingue aujourd'hui essentiellement deux branches de kernels : les kernels 2.4 et les kernels 2.6. En pratique, on croise surtout des noyaux 2.6. Les deux numéros qui suivent désignent la révision majeure et la révision mineure (respectivement 31 et et 2 dans 2.6.32-2). Tout l'historique est ici :
https://fr.wikipedia.org/wiki/Noyau_Linux

La dernière chose qui caractérise un kernel est l'architecture pour laquelle il a été compilé (i386 pour les PC 32 bits ordinaires, i686 pour les PC intel 32 bits, amd64 pour les amd 64 bits, et ia64 pour les intel 64 bits). On choisit donc en général un noyau optimisé pour son microprocesseur. Ceci dit rien n'empêche d'utiliser un noyau 32 bits sur une architecture 64 bits.

On peut voir la version de noyau lancée avec la commande "uname -a". Pour plus de détails, tape dans une console :

man uname

Plus de détails ici :
http://doc.ubuntu-fr.org/kernel_optimise

Les modules

Les modules sont des "morceaux" de kernel chargés ou déchargés à volonté après le chargement du noyau. Il y a deux façons de construire un module. Soit on a récupéré des sources de noyau, et on a décidé à la compilation de ce noyau de compiler certaines fonctionnalités dans le noyau, d'autres sous forme de module. Ce qu'il faut bien voir, c'est qu'on peut choisir de supporter une fonctionnalité soit directement en l'intégrant dans le noyau, soit en l'externalisant dans un module. Ceci se décide lorsqu'on compile le noyau.

Les modules chargés automatiquement au démarrage sont référencés dans /etc/module. Un module est chargé avec une commande modprobe ou insmod, et déchargé avec la commande rmmod. On peut voir les modules chargés avec la commande lsmod.

Pour plus de détails, tape dans une console :

man modprobe
man insmod
man rmmod
man lsmod

Les modules sont des fichiers ".ko" rangés dans /lib/modules. Si tu te promènes dans cette arborescence, tu verras ensuite que ces modules sont classés par version de kernel. En effet, un module ne peut se charger avec succès que si l'on a démarré sur le noyau correspondant.

Plus de détails ici :
http://doc.ubuntu-fr.org/tutoriel/tout_savoir_sur_les_modules_linux

Notions de compilation

Le noyau linux est écrit en langage C, c'est à dire sous forme de fichiers .c (les fichiers d'implémentation, le code source proprement dit) et de fichiers .h (les headers, qui déclarent ce qui est implémenté dans le .c). Au final, les fichiers .c et .h ne sont que des fichiers textes écrits par des développeurs et qui seront moulinés par un compilateur (gcc) en vue de produire un noyau et des modules (les .ko).
http://doc.ubuntu-fr.org/gcc

Étant donné la palanquée de fichiers, on ne va pas tous les compiler à la main et on utilise généralement un makefile qui permet de tout faire d'un coup. C'est pour ça que tu verras beaucoup de tutoriel sur la compilation d'un noyau qui parlent de la commande "make". Note bien que make-kpkg permet de s'abstraire de tout ça.
http://pwet.fr/man/linux/commandes/make_kpkg/
http://man.developpez.com/man1/make.1.php

De manière générale, un programme C a besoin pour s'interfacer avec un noyau / une librairie /... compilé en C des headers qui correspondent. Ainsi, gcc sait comment compiler un module / un programme / ... capable de s'interfacer avec.

Ainsi, quand un noyau est compilé, on n'a besoin que des headers correspondants (les .h) pour compiler un module.

Paquets requis

Ce qui est bien sous linux, c'est que quand on a besoin de quelque chose, il peut dans 99% des cas être facilement être installé par un paquet, ce qui évite de télécharger des trucs mystérieux sur des sites mystérieux. On utilise simplement un gestionnaire de paquets (aptitude ou apt-get par exemple sous debian, synaptic sous ubuntu...).
http://doc.ubuntu-fr.org/aptitude
http://doc.ubuntu-fr.org/synaptic

Tout ce qui concerne les noyaux et les modules ne déroge pas à la règle.

- Les noyaux précompilés (noyau + .ko) sont fournis par les paquets linux-image-...
- Les headers de noyaux (.h) sont fournis sous debian (et distributions dérivées) par les paquets linux-headers-... Ils ne servent que si on a pas les sources complète d'un noyau (sous entendu, on utilise un noyau précompilé).
- Les sources complètes (.h et .c) sont fournies les paquets linux-source-...

Pour compiler un module, on passe généralement sous debian par l'outil module-assistant. Ce petit outil permet de facilement compiler les modules "classiques" sous debian (ndiswrapper, lirc, etc...) qui ne sont pas prise en charge directement par le noyau. Le soucis c'est que la fonctionnalité que tu veux modifiée est à mon avis directement intégrée dans le kernel debian, donc forcément, pas proposé par module-assistant. Ainsi il faut garder à l'esprit cet outil, même si dans ton cas il ne t'aidera a priori pas.

Indépendamment de la distribution, pour que gcc puisse construire un module capable de s'interfacer avec un noyau utilisé, il lui faut soit les headers correspondants, soit les sources complètes de ce noyau (qui incluent les headers). Généralement, on crée un lien symbolique /usr/src/linux qui pointent vers les sources/headers du noyau concerné.

De plus, il faudra installer tous les paquets nécessaires à la compilations (gcc, make, ...).

Retour sur ton problème

La première chose tu l'auras compris, c'est que la fonctionnalité que tu modifies peut être soit interne au kernel, soit externalisée dans un module. C'est toi qui voit au moment où tu compiles ton noyau...

La seconde chose, c'est que dans ce cas il te faudra bien des sources de noyau, les corriger à ton idée, et passer par le makefile du noyau ou par make-kpkg pour le compiler.

Le troisième point, c'est que si tu es sous debian ou une distribution qui en dérive, tu as plein d'outils dont tu aurais tort de te priver (make-kpkg). Sinon il faudra le faire à l'ancienne via le makefile livré avec tes sources de noyau. Tout est expliqué ici :
https://www.debian.org/doc/manuals/debian-reference/ch09.fr.html

Bonne chance

lami20j · Answer

Salut,

Chapeau pour le cours, Miss ;-)

Il s'agit de modifier le Linux-Kernel de ma machine virtuelle, de façon à ce que chaque paquet IP rentrant soit enregistré dans le Kernel-Log. 

Je ne suis pas sur que tu dois modifier quelque chose dans le kernel  pour faire ça.
Tape cette commande pour voir

~$ grep -i CONFIG_IP_NF_TARGET_LOG /boot/config-$(uname -r)
CONFIG_IP_NF_TARGET_LOG=m

Si tu as ce résultat alors normalement ça ne sera qu'une histoire d'écriture de règles iptables pour les LOG et de configuration de l'édition de fichier /etc/syslog.conf ou /etc/rsyslog.conf




man iptables

 LOG
       Turn on kernel logging of matching packets.  When this option is set for a rule, the Linux kernel will print some information on all matching packets (like most IP header fields) via the kernel log (where it can be read with
       dmesg  or  syslogd(8)).   This is a "non-terminating target", i.e. rule traversal continues at the next rule.  So if you want to LOG the packets you refuse, use two separate rules with the same matching criteria, first using
       target LOG then DROP (or REJECT).

       --log-level level
              Level of logging (numeric or see syslog.conf(5)).

       --log-prefix prefix
              Prefix log messages with the specified prefix; up to 29 letters long, and useful for distinguishing messages in the logs.

       --log-tcp-sequence
              Log TCP sequence numbers. This is a security risk if the log is readable by users.

       --log-tcp-options
              Log options from the TCP packet header.

       --log-ip-options
              Log options from the IP packet header.

       --log-uid
              Log the userid of the process which generated the packet.

Voici un exemple concret chez moi.

Règle iptables 

iptables -A INPUT -s 10.0.0.10 -j LOG --log-prefix '** PIRATE 10.0.0.10 LAN **' --log-level 4
iptables -A INPUT -s 10.0.0.10 -j DROP

Configuration de rsyslog.conf
kern.warning /var/log/kern.log
Pas nécessaires vu que dans rsyslog.conf j'ai déjà kern.*                          -/var/log/kern.log
C'était juste pour être explicite.


Redémarrage de daemon rsyslogd
debian:/home/lami20j# /etc/init.d/rsyslog restart
Stopping enhanced syslogd: rsyslogd.
Starting enhanced syslogd: rsyslogd.
debian:/home/lami20j# exit
exit
lami20j@debian:~$ 

Et voici les logs dans /var/log/kern.log suite par exemple à un ping -c2 10.0.0.3 depuis la machine LAN 10.0.0.0

Jan 16 10:43:26 debian kernel: imklog 3.18.6, log source = /proc/kmsg started.
Jan 16 10:43:34 debian kernel: [ 7155.001764] ** PIRATES 10.0.0.10 **IN=eth0 OUT= MAC=x:x:x:x:x:x:x:x:x:x:x:x:x:00 SRC=10.0.0.10 DST=10.0.0.3 LEN=84 TOS=0x00 PREC=0x00 TTL=64 ID=0 DF PROTO=ICMP TYPE=8 CODE=0 ID=53002 SEQ=1              
Jan 16 10:43:34 debian kernel: [ 7155.001764] ** PIRATES 10.0.0.10 **IN=eth0 OUT= MAC=x:x:x:x:x:x:x:x:x:x:x:x:x:00 SRC=10.0.0.10 DST=10.0.0.3 LEN=84 TOS=0x00 PREC=0x00 TTL=64 ID=0 DF PROTO=ICMP TYPE=8 CODE=0 ID=53002 SEQ=1
 

Ou pour un essai de connexion ssh
Jan 16 10:44:41 debian kernel: [ 7221.464977] ** PIRATES 10.0.0.10 **IN=eth0 OUT= MAC=x:x:x:x:x:x:x:x:x:x:x:x:x:00 SRC=10.0.0.10 DST=10.0.0.3 LEN=60 TOS=0x00 PREC=0x00 TTL=64 ID=36515 DF PROTO=TCP SPT=40780 DPT=22 WINDOW=5840 RES=0x00 SYN URGP=0              
Jan 16 10:44:41 debian kernel: [ 7221.464977] ** PIRATES 10.0.0.10 **IN=eth0 OUT= MAC=x:x:x:x:x:x:x:x:x:x:x:x:x:00 SRC=10.0.0.10 DST=10.0.0.3 LEN=60 TOS=0x00 PREC=0x00 TTL=64 ID=36515 DF PROTO=TCP SPT=40780 DPT=22 WINDOW=5840 RES=0x00 SYN URGP=0              
Jan 16 10:44:44 debian kernel: [ 7224.463585] ** PIRATES 10.0.0.10 **IN=eth0 OUT= MAC=x:x:x:x:x:x:x:x:x:x:x:x:x:00 SRC=10.0.0.10 DST=10.0.0.3 LEN=60 TOS=0x00 PREC=0x00 TTL=64 ID=36516 DF PROTO=TCP SPT=40780 DPT=22 WINDOW=5840 RES=0x00 SYN URGP=0              
Jan 16 10:44:44 debian kernel: [ 7224.463585] ** PIRATES 10.0.0.10 **IN=eth0 OUT= MAC=x:x:x:x:x:x:x:x:x:x:x:x:x:00 SRC=10.0.0.10 DST=10.0.0.3 LEN=60 TOS=0x00 PREC=0x00 TTL=64 ID=36516 DF PROTO=TCP SPT=40780 DPT=22 WINDOW=5840 RES=0x00 SYN URGP=0              




Voici un lien https://www.linuxtopia.org/Linux_Firewall_iptables/x651.html

Arthur · Answer

Merci beaucoup pour les explications très détaillées.
Si j'ai bien compris, le noyau serait comme la matrice qui permettrait au forgeron d'exercer sa force et de marquer une pièce de monnaie ? Et les modules serait les alvéoles et symboles associables dans ladite matrice.
Je retiens la commande make-kpkg, qui permet donc de compiler les sources.

La commande uname -a me donne :
Linux ubuntu 2.6.31-14-generic #48-Ubuntu SMP Fri Oct 16 14:04:26 UTC 2009 i686
C'est donc le kernel -generic et non le second qui est utilisé, si j'ai suivi.
Si je ne m'abuse, on a du 32 bits, puisque la machine virtuelle est ancrée dans mon Windows Seven 32 bits.

modprobe sert à ajouter ou supprimer des modules.
insmod sert à insérer un module dans le noyau.
rmmod sert à supprimer un module du noyau.
lsmod sert à consulter l'état des modules.
J'ai tout compris ?

Pour ce qui est de la compilation du noyau, je me demandais s'il fallait avoir un compiler spécial C ou si Ubuntu en était déjà pourvu. Je n'y connais vraiment rien du tout, n'ayant pour le moment que programmé en Java.

Mais au final, je ne sais toujours pas trop quoi faire...
Je crois avoir saisi qu'il faudrait créer ou trouver un module qui aie l'effet désiré, mais je n'ai pas la moindre idée de comment marchent les modules.

À part ça, j'ai eu droit à une indication de la part d'un professeur.
Traduit de l'allemand, ça donne : "Tu auras besoin pour cela des Sources-noyau, devra trouver le bon Datei, entrer au bon endroit un Log-Output, puis recompiler le noyau et tester le nouveau noyau ainsi obtenu."




Ensuite, pour répondre à lami20j.
Avec la commande ~$ grep -i CONFIG_IP_NF_TARGET_LOG /boot/config-$(uname -r)
, j'ai bien pour résultat CONFIG_IP_NF_TARGET_LOG=m.
Après, je n'ai pas bien compris ton exemple. Peux-tu me ré-expliquer comment on créer les règles iptable, que l'on modifie rsyslog.conf ?
Pour le redémarrage du daemon, j'ai compris.
J'ai lu, sur la page dont tu m'as donné le lien : "CONFIG_IP_NF_TARGET_LOG - This adds the LOG target and its functionality to iptables. We can use this module to log certain packets to syslogd and hence see what is happening to the packet. This is invaluable for security audits, forensics or debugging a script you are writing."


Merci beaucoup pour votre aide.
Arthur

lami20j · Answer

Re,

, j'ai bien pour résultat CONFIG_IP_NF_TARGET_LOG=m. 

Alors tu n'as pas besoin d'une récompilation pour ce cas.
En revanche pour mieux comprendre ce qui ce passe continue à lire ce que mamiemando t'a donnée.

Après, je n'ai pas bien compris ton exemple. Peux-tu me ré-expliquer comment on créer les règles iptable,

Ben, il suffit de taper dans un terminal, en root les deux ligne que tu vois dans mon exemple. Bien sûr il faut modifier l'ip.

Pour aller plus loin il faut lire la documentation.
Soit tu fait un script qui contiendra les règles de ton firewall soit tu utilises un frontend qui te permettra de créer les règles de ton firewall.

que l'on modifie rsyslog.conf ? 
Tu utiliseras un editeur de texte, vim, nano, gedit, kwrite, etc. et ajouter la ligne que j'ai mis.
Ou avec la commande suivant en root
echo "kern.warning /var/log/kern.log" >> /etc/rsyslog.conf 

Il faut vérifier comment s'appelle le fichier chez toi. Plus facile sera de nous dire quelle distribution tu utilises.

lami20j · Answer

Re,

À part ça, j'ai eu droit à une indication de la part d'un professeur.
Traduit de l'allemand, ça donne : "Tu auras besoin pour cela des Sources-noyau, devra trouver le bon Datei, entrer au bon endroit un Log-Output, puis recompiler le noyau et tester le nouveau noyau ainsi obtenu." 

Soit tu n'as pas bien exposé le problème ou jai mal compris ce que tu veux, et en ce cas ton prof t'a donné une indication.
Soit tu dois tout simplement diriger les logs d'iptables vers le fichier /var/log/kern.log et en ce cas tu peux donner à ton prof le lien de ma 1ère réponse.

Arthur · Answer

J'ai entré les deux lignes de commande. Pas d'erreur.
J'ai mis mon adresse IP à la place des "10.0.0.10", c'est juste ?
J'ai aussi fait la modification du .conf
Pas d'erreur non plus.
Mais je fais quoi maintenant ?

(Distribution : Ubuntu)
Pour ce qui est de l'indication, je n'y comprend pas grand chose. Tu dis bien qu'on a pas besoin de recompiler pour faire ça. Il faudrait aussi voir de que le fameux "Log-Output" en retourne...

lami20j · Answer

Re,

J'ai mis mon adresse IP à la place des "10.0.0.10", c'est juste ? 
Ce n'est pas ton IP que tu dois mettre, mais l'IP d'une autre machine.

Mais je fais quoi maintenant ? 
Tu fais un ping de la machine externe vers ta machine et tu regardes les logs?

Pour ce qui est de l'indication, je n'y comprend pas grand chose. Tu dis bien qu'on a pas besoin de recompiler pour faire ça. Il faudrait aussi voir de que le fameux "Log-Output" en retourne...
Ben, tu n'as qu'à regarder dans le fichier de log pour voir ce que le filtrage retourne.

lami20j · Answer

Re,

En fait c'est grâce au règles que tu vas filtrer le trafic des paquets sur ton réseau.
Ce que je t'ai montré, ce n'était en fait qu'un exemple.

Tu peux créer des règles aussi pour les paquets sortant, pour les paquets qui circulent entre plusieurs interfaces réseau de la même machine.

Mais ça c'est une autre histoire. Il faut comprendre le fonctionnement de firewall.
Sous Ubuntu il y a un frontend qui te permettra de créer des règles si tu ne veux pas utiliser la ligne de commande. http://doc.ubuntu-fr.org/gufw

Après avoir créer des règles avec gufw il suffit de taper dans une console 
sudo iptables-save pour voir les règles crée avec le frontend.
Ça te permettra de comprendre et d'avancer tout doucement.

Arthur · Answer

En faisant "man iptables", je vais essayer de me familiariser avec la chose.

lami20j · Answer

Re,

Voici 2 liens sympa avec des exemple concrets 
http://olivieraj.free.fr/fr/linux/information/firewall/
http://irp.nain-t.net/doku.php/130netfilter:start

bob031 · Answer

Bonjour,


voici qui devrait éclairer, à la plupart d'entre nous, notre lanterne :

CONFIG_IP_NF_TARGET_LOG - Ceci ajoute à iptables la cible LOG avec ses fonctionnalités
source : https://inetdoc.net/guides/iptables-tutorial/kernelsetup.html

La cible LOG est spécialement destinée à journaliser des informations détaillées sur les paquets.
source : https://inetdoc.net/guides/iptables-tutorial/logtarget.html


qu'en est-il sur chez moi :

> redfox@mandriva[192.168.1.2]:~$ cat /usr/src/linux-2.6.31.5-desktop586-1mnb/.config | grep -i log
CONFIG_LOG_BUF_SHIFT=17
CONFIG_NETFILTER_NETLINK_LOG=m
CONFIG_NETFILTER_XT_TARGET_NFLOG=m
CONFIG_IP_NF_TARGET_LOG=m
CONFIG_IP_NF_TARGET_ULOG=m
CONFIG_IP_NF_TARGET_IFWLOG=m
CONFIG_IP6_NF_TARGET_LOG=m


ce tip (en anglais) devrait également répondre à tes questions :

https://www.cyberciti.biz/tips/how-can-i-enable-or-setup-log-message-in-the-iptables-firewall.html

Arthur · Answer

Merci beaucoup. Le tout a marché. Seul soucis : faire une image initrd.
Je sais qu'il me faut "mkinitrd" pour cela, mais je ne le trouve nulle part (enfin, je le trouve pour les i386, mais j'ai un i686...).
Sauriez-vous où trouver ce machin ?
En faisant l'idiot, j'ai déjà eut une perte de données à cause de cela (merci "Kernel panic" !)

mamiemando · Answer

Pose ta question dans un autre fil de discussion car elle n'a plus rien à voir avec le sujet initial.

Bonne continuation

Modification de noyau

13 réponses

Discussions similaires