https://lea-linux.org/docs/api.php?action=feedcontributions&feedformat=atom&user=EsaLea Linux - Contributions [fr]2026-04-26T10:07:51ZContributionsMediaWiki 1.40.1https://lea-linux.org/docs/index.php?title=Tenir_compte_de_la_s%C3%A9curit%C3%A9_au_quotidien&diff=13100Tenir compte de la sécurité au quotidien2006-07-19T09:01:51Z<p>Esa : /* Firewalls */</p>
<hr />
<div>[[Category:Fiche sécurité]]<br />
<div class="leapar">Par [[Utilisateur:Merlin8282|merlin8282]] et [[Utilisateur:Fleury|Fleury]].</div><br />
== Introduction ==<br />
Un ordinateur n'est jamais en sécurité, quand bien même on croit qu'il l'est. Un dicton informatique dit d'ailleurs que l'ordinateur le plus sûr est celui qui est éteint.<br />
<br />
Cette fiche est là pour vous faire découvrir les différents risques que l'on court en ayant un ordinateur, connecté à un réseau ou non, ainsi que pour se parer contre la plupart des attaques et enfin pour savoir comment nettoyer l'ordinateur après une attaque que l'on vient de subir.<br />
<br />
Pour tout le document (et de manière générale), il est évidemment conseillé de lire les pages de manuel des commandes avant de poser des questions.<br />
Lisez aussi les articles connexes en cliquant sur les hyperliens dans le texte car dans ce document je ne m'étale justement pas sur les sujets pour lesquels il existe déjà un article.<br />
<br />
== Avant tout, connaître son système ==<br />
D'abord et avant tout il faut être à l'aise avec les concepts essentiels de [http://fr.wikipedia.org/wiki/Linux Linux]. Cela permettra d'une part de mieux connaître et comprendre ce que nous faisons et d'autre part de mieux réagir en cas d'attaque. Donc, documentez vous sur ce système et son langage de commande ([[Admin-admin_env-shell|shell]]).Lisez aussi la documentation expliquant ce que sont [[Admin-admin_boot-daemons|les démons et comment ils fonctionnent]]. Voyez comment fonctionne un réseau, ce que sont les ports réseau, les permissions des fichiers, ce que sont les failles de sécurité des logiciels, etc.<br />
<br />
== Connaître les risques ==<br />
La sécurité informatique est un domaine que l'on pourrait séparer en trois parties. La première s'occupe de la sécurité des données, c'est la cryptologie, la plus connue et la plus théorique des trois. La seconde s'occupe de la sécurité des protocoles, elle comprend notamment la sécurité réseau. Enfin, la dernière et la moins connue des trois est la sécurité logicielle, elle s'occupe notamment des failles du genre débordement de tampon (buffer-overflow) et autres (format string, integer overflow, etc). <br />
<br />
Dans ce petit survol des risques potentiels en matière de sécurité informatique nous aborderons la sécurité réseau et la sécurité logicielle. La cryptologie ne sera pas abordée car c'est une science très complexe et de toute façon inaccessible au simple utilisateur. Pour finir nous aborderons l'ingénierie sociale qui reste inclassable mais qui est un risque non négligeable.<br />
<br />
=== La sécurité réseau ===<br />
Le but de la sécurité réseau est de connaître les forces et les faiblesses des protocoles. Du point de vue de l'attaquant, on se posera des questions comme: ''Comment abuser un firewall ? Comment tirer un maximum d'informations d'un serveur ? Comment aveugler un système de détection d'intrusion ?'' Du point de vue du défenseur, les questions qui se posent sont surtout comment détecter les comportements réseaux anormaux et empêcher (ou au moins réagir face à) une attaque.<br />
<br />
Un certain nombre de mots clefs sont associés à la sécurité réseau. Ainsi on parle de firewalls, d'IDS, d'IPS, de scanneurs réseaux, de sniffeurs et autres. Nous allons ici définir quelques-uns de ces mots.<br />
<br />
==== Firewalls ====<br />
Pour le définir de manière concise, un firewall (pare-feu) est un filtre réseau qui va pouvoir stopper certains paquets réseau. Suivant le type de trafic qu'ils analysent et à quel niveau ils se placent sur la couche OSI on va parler de plusieurs types de firewalls:<br />
<br />
* '''Stateless firewall''': Ce firewall est le plus basique, il ne fait que regarder les paquets réseau un par un et les accepte ou les rejette uniquement sur la base de son fichier de configuration.<br />
<br />
* '''Stateful firewall''': Aussi appelé ''connection tracking firewall'', ce firewall permet de tirer parti d'une connaissance du protocole (TCP par exemple). Il garde en mémoire les connections qui sont en cours et l'état dans lequel elles sont (en cours d'établissement, établie, en train d'être achevées, etc). L'avantage de ce firewall est qu'il permet une configuration plus fine avec moins de lignes mais son inconvénient est qu'il utilise un peu de mémoire pour chaque connexion et qu'il est susceptible de se faire saturer (Déni de service).<br />
<br />
* '''Firewall applicatif''': Il en existe plusieurs sortes : les proxy, les filtres de contenu (clamav), etc. sont tous des firewalls applicatifs. Contrairement aux firewalls précédents qui résident habituellement dans le noyau, les firewalls applicatifs sont habituellement basés dans l'espace utilisateur. Ces firewalls servent le plus souvent de relais avec éventuellement un contrôle sur le contenu de ce qui transite (quoique le plus souvent les proxy web ne contrôlent pas le contenu des requêtes même s'ils le pourraient).<br />
<br />
Sous Linux, le firewall par défaut est [http://www.netfilter.org/ Netfilter], il possède la capacité de faire du Stateless et du Stateful pour divers protocoles. Les firewalls applicatifs existent aussi mais ne sont pas gérés par Netfilter. Nous verrons plus loin comment piloter Netfilter à l'aide de iptables.<br />
<br />
==== Scanneur réseau ====<br />
Un scanneur réseau est simplement un petit logiciel qui tente d'explorer un réseau ou une machine de façon distante (c'est à dire via le réseau). Pour cette exploration le scanneur va tenter de se connecter à une ou plusieurs machines de façon directe ou indirecte. Il faut bien comprendre que le but premier du scanneur de réseau est de collecter de l'information (présence/abscence de services) sur un réseau ou une machine et uniquement cela. L'usage d'un scanneur est par conséquent légal (sauf si vous avez signé une charte qui dit le contraire) mais collecter beaucoup d'informations sur un réseau peut vous rendre suspect aux yeux de ceux qui le gèrent.<br />
<br />
Le plus connu des scanneur est sans conteste [http://www.insecure.org/nmap/ nmap]. Il possède un grand nombre d'options et permet d'extraire beaucoup d'informations sur votre environnement réseau. Pour peu que vous soyez root sur la machine que vous utilisez, vous pouvez tenter le jeu d'options suivant (regardez le manuel pour savoir ce qu'elles font): -F -O -sV<br />
<br />
<code>nmap</code> est bien sûr un scanneur réseau ''basique'', il en existe des bien plus avancés qui utilisent nmap comme brique de base mais qui scannent non plus les services réseau mais les vulnérabilités. On peut ainsi citer [http://www.nessus.org/ nessus] qui permet de tester son réseau contre un grand nombre d'attaques.<br />
<br />
Lorsqu'un pirate veut s'en prendre à vous, la première chose qu'il fera sera de vous scanner et extraire un maximum d'informations sur votre réseau. Mieux vaut savoir quelles informations vous laissez filtrer à l'extérieur pour connaître vos faiblesses.<br />
<br />
==== Sniffeurs ====<br />
Un sniffeur est un petit logiciel qui va se mettre à l'écoute de tous les paquets réseau qui passent à la portée de votre ordinateur. Habituellement votre machine ne va considérer que les paquets qui vous sont addressés mais l'on peut pervertir l'usage habituel et faire en sorte que votre machine vous permette d'accéder aussi aux paquets qui ne vous sont pas adressés. On appelle cela le mode ''promiscuous'' pour les cartes ethernet et le mode ''monitor'' pour les cartes wifi.<br />
<br />
Les sniffeurs sont largement utilisés à la fois par les pirates et par les ingénieurs systèmes. Les pirates les utilisent essentiellement pour récupérer des informations sur un réseau ou même plus. En effet, lorsqu'ils ont compromis une machine de votre réseau, il peuvent laisser tourner de façon cachée un de ces sniffeurs qui va collecter les informations utiles qui transitent par la carte réseau de la machine piratée. Ainsi, tous les mots de passe en clair peuvent être récupérés à moindre frais. D'un autre coté, les administrateurs réseaux ont aussi un grand usage des sniffeurs, ils servent le plus souvent de débogueur réseau mais aussi d'espion pour essayer d'identifier des comportements sur le réseau qui ne seraient pas normal ou qui laisseraient supposer à une attaque (voir les IDS plus loin).<br />
<br />
Il existe un très grand nombre de sniffeurs réseau, les deux plus connus sont sans doute [http://www.wireshark.org wireshark] (ex-[http://www.ethereal.com/ ethereal]) et [http://www.tcpdump.org tcpdump]. D'autres sont plus spécialisés comme par exemple [http://lcamtuf.coredump.cx/p0f.shtml p0f] (sniffeur passif de détection d'OS), [http://www.monkey.org/~dugsong/dsniff/ dsniff] (sniffeur de mots de passe) ou encore [http://www.kismetwireless.net/ kismet] (sniffeur wifi).<br />
<br />
==== IDS, IPS et honeypots ====<br />
Pour finir ce petit tour de la sécurité réseau nous allons faire un tour du coté des armes auxquelles vous avez accès pour vous défendre. <br />
<br />
Pour faire court, les IDS (Intrusion Detection Systems) sont des sondes qui espionnent votre réseau et enregistrent les phénomènes bizarres ou qui pourraient ressembler à des attaques potentielles. Le rôle d'un IDS n'est pas de prévenir des attaques mais vraiment de jouer un rôle similaire à celui de la boîte noire d'un avion après une catastrophe afin de savoir ce qui s'est passé et éventuellement collecter des preuves contre les attaquants.<br />
<br />
Il y a trois types d'IDS :<br />
* les '''IDS réseaux''' du genre [http://www.snort.org snort] qui s'assurent de l'intégrité d'un réseau par une analyse du trafic qu'il y a dessus,<br />
<br />
* les '''IDS systèmes''' du genre [http://sourceforge.net/projects/tripwire/ tripwire] qui s'assurent de l'intégrité d'un système en stockant un [http://fr.wikipedia.org/wiki/Cyclic_redundancy_check CRC] des principaux fichiers de configuration et des binaires pour s'assurer qu'ils n'ont pas été corrompu,<br />
<br />
* les '''IDS hybrides''' qui tentent de rassembler les deux précédents, du genre [http://www.prelude-ids.org/ prelude-IDS].<br />
<br />
Les IPS (Intrusion Prevention Systems) sont à peine différents des IDS puisqu'en cas de détection d'une attaque probable, alors que l'IDS se contente d'enregistrer les logs, l'IPS tente de contrer l'attaque en réagissant. <br />
<br />
Enfin, les [http://fr.wikipedia.org/wiki/Honeypot honeypots] (pots de miel) sont des simulations de machines faibles. La constatation est simple, les pirates s'attaquent logiquement toujours au point le plus faible de votre réseau. Avoir des points faibles factices et bardés d'alarmes discrètes vous permet non seulement de détourner momentanément les pirates des vraies machines, de les freiner mais aussi de détecter plus facilement les intrus qui se laissent prendre au piège.<br />
<br />
Voila, nous avons fait un (très) rapide tour des mots clefs importants en matière de sécurité réseau. Nous allons à présent quitter le réseau et nous intéresser de plus près à ce qui se passe sur vos serveurs et vos machines.<br />
<br />
=== La sécurité logicielle ===<br />
Lorsque les pirates n'en ont pas après ce qui circule sur votre réseau, c'est qu'ils tentent de pénétrer une (ou plusieurs) machine(s) et c'est là que commence la sécurité logicielle...<br />
<br />
Il faut savoir qu'en informatique il existe des logiciels malveillants ([http://fr.wikipedia.org/wiki/Logiciel_malveillant malware] en anglais). Ces logiciels peuvent être des virus, des vers, des chevaux de Troie ou encore des rootkits. Mais ils ont tous en commun d'exploiter des failles classiques ou de rendre les systèmes sur lesquels ils résident plus faibles face à des attaquants extérieurs.<br />
<br />
==== Virii et Vers ====<br />
Un virus est un petit programme qui a la particularité de se reproduire et de se propager d'un système à l'autre suivant certains vecteurs. Cela peut être les mails ou même l'utilisateur lui-même qui va copier le logiciel sur d'autres systèmes. Les vers sont une sorte particulière de virus qui se propagent uniquement via le réseau Internet (l'un des plus célèbre fut Blaster en 2003 qui visait essentiellement des systèmes Microsoft Windows). Certains virus fonctionnent et infectent les systèmes linux, mais leur nombre est plus réduit que ceux qui attaquent les systèmes Windows. Grâce à la rareté de ces virus et à la réactivité de la communauté libre face aux nouvelles failles découvertes, ce genre de malware ne se propage que très difficilement sur les systèmes Linux, et par conséquent Unix. Cependant il faut être vigilant et appliquer régulièrement les correctifs de sécurité de votre système pour ne pas s'exposer à des malwares, qui pourraient alors s'infiltrer facilement via les failles que vous auriez laissé béantes.<br />
<br />
==== Chevaux de Troie ====<br />
Les chevaux de Troie sont des logiciels qui tentent d'abuser l'utilisateur en se faisant passer pour autre chose que ce qu'ils sont réellement (un jeu, un petit utilitaire, ou encore une commande classique comme <code>ssh</code>, pour collecter les mots de passe vers d'autres systèmes, etc). Ils peuvent être aussi un vecteur de propagation pour les virus comme le célèbre ver "I love you" qui se propageait par mail ou aussi être contenu dans un virus qui va l'installer sur le système qu'il a infecté avant de tenter de se propager vers d'autres systèmes.<br />
<br />
==== Rootkits ====<br />
Enfin, les [http://fr.wikipedia.org/wiki/Rootkit rootkits] sont des logiciels qui facilitent l'accès réseau discret des pirates sur le système. Leur nom vient du fait qu'ils permettent aux pirates d'accéder au système infecté avec des droits équivalents (ou même supérieurs) au root. À l'origine ces rootkits étaient un ensemble de chevaux de Troie mimant les commandes classiques du système (<code>ps</code>, <code>login</code>, <code>ls</code>, etc). De nos jours, les rootkits sont quasi-essentiellement des kernel-rootkits, c'est à dire qu'ils se branchent directement sur le noyau pour modifier les informations que pourraient lire les utilisateurs du système. Ce dernier type de rootkit permet aux pirates une réelle invisibilité du point de vue des autres utilisateurs (y compris du root). Vous l'aurez compris, ces rootkits sont très difficiles à repérer avec des moyens standards et compromettent très profondément votre système. C'est pour cela qu'il n'est jamais mauvais d'installer et de lancer régulièrement [http://www.chkrootkit.org/ chkrootkit], qui vérifie la présence de rootkits.<br />
<br />
==== Attention aux mélanges !!! ====<br />
Évidemment, tout ces malwares peuvent se combiner entre eux pour former des combinaisons souvent difficiles à contrer. On peut citer l'exemple du vers 1i0n ([http://www.cert.org/incident_notes/IN-2001-03.html rapport CERT], Mars 2001) qui ciblait essentiellement des failles sur les systèmes Unix faisant tourner un serveur BIND et qui installait le rootkit ''erkms'' avant de continuer à se propager. Ce malware combinait à la fois un ver et un rootkit lui-même composé d'un certain nombre de chevaux de Troie.<br />
<br />
=== Ingénierie sociale ===<br />
Une dernière technique de piratage existe et bien qu'elle soit inclassable du point de vue technique c'est probablement la plus efficace. <br />
<br />
Souvent, si le pirate est un ''insider'' (quelqu'un de l'intérieur), il aura simplement recours à de l'[http://fr.wikipedia.org/wiki/Ingénierie_sociale ingénierie sociale]. C'est une méthode consistant à profiter de la crédulité des gens qui souvent écrivent leurs mots de passe sur un bout de papier et le laissent à proximité de l'ordinateur. D'autres sont par exemple appelés par l'attaquant, se faisant alors passer pour le service technique de l'entreprise, qui prétend avoir besoin du mot de passe de l'utilisateur pour faire des tests.<br />
<br />
Cela peut paraître trivial mais c'est la technique qui donne le plus de résultats avec le moins d'investissement en temps et en connaissance. [http://fr.wikipedia.org/wiki/Kevin_Mitnick Kevin Mitnick], un des rois du piratage était passé maître dans ce type d'attaques. Il avait un applomb et un génie de l'improvisation allié avec des connaissances techniques hors du commun qui lui ont permis de réaliser des miracles (du mauvais côté de la loi, hélas).<br />
<br />
== Protéger son ordinateur ==<br />
=== Sécuriser son boot ===<br />
Si l'accès physique à la machine est une faille, il faut configurer son bios. Celui-ci ne doit autoriser que le boot sur disque dur, et doit être protégé par mot de passe.<br />
[http://fr.wikipedia.org/wiki/GRand_Unified_Bootloader Grub] permettant d'éditer manuellement le boot (périphérique de démarrage, noyau, options pour l'init...), il est nécessaire de le protéger par mot de passe afin qu'on ne puisse pas modifier les configurations prédéfinies.<br />
En fait il est même parfois conseillé de supprimer tout périphérique susceptible d'être source d'insécurité à ce niveau, comme le lecteur de disquettes par exemple. Cela dit, si c'est une station de bureau il vaut mieux garder ce dont on a besoin, cela va sans dire. C'est à vous d'en juger.<br />
<br />
De toute manière, un système n'est jamais sûr puisque pour l'exemple présent, il est possible de supprimer le mot de passe du [http://fr.wikipedia.org/wiki/Basic_Input_Output_System BIOS] en réinitialisant celui-ci. Ainsi pour quelqu'un ayant un accès physique à la machine il est facile d'ouvrir le boîtier et de retirer quelques secondes la batterie alimentant le BIOS. La parade consisterait à verrouiller l'accès à l'intérieur de la machine (cadenas).<br />
<br />
Pire encore : le BIOS étant de nos jour stocké dans une mémoire accessible en écriture -- généralement de la mémoire flash. Sur les carte-mères plus anciennes le BIOS est stocké dans une ROM. -- ce qui permet potentiellement à quelqu'un de le flasher (le mettre à jour) pour le remplacer par une version vérolée.<br />
<br />
Avant de continuer sur le BIOS, voyons un peu comment celui-ci fonctionne et pourquoi il existe :<br />
<br />
Immédiatement à la mise sous tension, le BIOS déroule la procédure de POST (''Power-On Self Test'' ou ''vérification de mise sous tension''). Durant cette phase, le BIOS effectue divers contrôles : [http://fr.wikipedia.org/wiki/Processeur CPU], [http://fr.wikipedia.org/wiki/Somme_de_contrôle autovérification par chiffre de contrôle], contrôle des paramètres BIOS enregistrés (mémoire de "setup"), initialisation de divers composants (horloge, [http://fr.wikipedia.org/wiki/Accès_direct_mémoire DMA], etc), vérification de la mémoire, des périphériques (claviers, lecteur(s) de disquette, disque(s) dur(s), etc.).<br />
<br />
En cas d'erreur, le BIOS tente de continuer ou, en cas d'erreur grave il arrête le système et affiche, si possible, un message d'erreur. Autrement il fait une série de beep pour aider au diagnostic de la panne. Il envoie également un code sur le port série, code qui peut être récupéré par divers moyens.<br />
<br />
Immédiatement après le POST, le BIOS va charger le premier secteur du disque amorçable. Ce secteur contient un petit programme de chargement (boot loader) du chargeur du (des) système(s) d'exploitation (grub, lilo ou, pour Windows, NTLDR). Le POST se termine en transférant l'exécution au boot loader. <br />
<br />
C'est en fait, à l'origine, la fonctionnalité principale (c'est elle qui a donné son nom au BIOS) du BIOS : fournir une couche logicielle d'abstaction (permettant d'ignorer lors de la programmation les aspects purement matériels) pour les périphériques les plus courants : clavier, écran, lecteur de disquettes, disques durs, souris, etc.<br />
On accède à ces fonctions par l'envoi d'interruptions logicielles ou, plus rarement, par accès direct à la mémoire BIOS.<br />
<br />
Fort heureusement, linux étant un bon système d'exploitation il n'utilise pas le BIOS, qui sert comme on l'a vu de couche d'abstraction entre le logiciel et le matériel. Le risque d'attaque via le BIOS est donc considéré comme nul. Cependant, il reste techniquement possible -- mais les pirates n'y auraient aucun intérêt -- de flasher le BIOS de telle sorte qu'il ne puisse plus booter l'ordinateur, bloqué dans une boucle infinie.<br />
<br />
=== Partitionnement conséquent ===<br />
À l'installation du système, il faut bien réfléchir au partitionnement des disques. Les données statiques (binaires, fichiers de configuration, etc.) seront sur une partition montée en lecture seule pour éviter toute modification :<br />
* /bin<br />
* /boot<br />
* /lib<br />
* /sbin<br />
* /usr<br />
Eventuellement d'autres dossiers, selon la distribution.<br />
<br />
Lorsque l'accès physique à la machine est une faille potentielle de sécurité, il n'est pas une mauvaise idée que de créer une partition dédiée à /etc , qui serait formatée en un système de fichiers chiffré (voir [http://www.tldp.org/HOWTO/Encrypted-Root-Filesystem-HOWTO/ Encrypted root filesystem howto]). Dans ce cas-là, même si on démarre l'ordinateur avec un LiveCD il devient impossible à moins d'avoir les identifiants idoïnes d'accéder aux données de la partition.<br />
<br />
=== N'installer que le strict nécessaire ===<br />
Chaque bout de code est potentiellement une faille. C'est pour cela que moins il y a de logiciels installés, plus le risque d'avoir une faille est réduit. Un exemple courant pour faire comprendre le principe est que sur un serveur il n'est généralement nul besoin de serveur X. Un autre exemple, dans un environnement unix il n'est nul besoin de serveur Samba.<br />
Une fois le ménage fait dans votre installation, il faut bien configurer ses logiciels. D'ailleurs pour être certain d'avoir une machine propre, faites l'installation hors-ligne et ne mettez la machine en réseau qu'une fois bien sécurisée, surtout au niveau de Netfilter/iptables.<br />
<br />
=== Utilisateurs ===<br />
Vérifier que root n'est pas autorisé à se connecter. [[Sudo|Utiliser sudo]] plutôt que [[Fiches:Securite-ficheroot|le compte root directement]] pour les tâches d'administration.<br />
Evitez par ailleurs d'avoir des comptes inutiles sur votre machine car même s'ils n'ont que des droits restreints, l'utilisation d'une faille par un intrus pour obtenir plus de permissions n'est pas impossible.<br />
<br />
=== Permissions ===<br />
De manière générale, éviter autant que possible de positionner les droits ''setuid'' et ''setgid'' d'un éxécutable, qui permettent, en particulier, d'exécuter un programme avec les droits de '''root''' alors qu'on est connecté en simple utilisateur.<br />
<br />
<cadre>'''setuid bit ''' droit donné à un fichier exécutable d'utiliser les droits du propriétaire du fichier éxécutable (en général le root).<br />
<br />
'''setgid bit''' droit donné à un fichier exécutable d'utiliser les droits du groupe propriétaires du fichier éxécutable.</cadre><br />
<br />
Utiliser [[Admin-admin_env-chroot|chroot]] pour les services et les utilisateurs distants qui doivent avoir un accès restreint à la machine.<br />
<br />
Pour plus d'information sur les droits, consulter la [[Permissions|documentation de Léa sur les permissions]]<br />
<br />
== Bien configurer ses démons ==<br />
[[Reseau-web-Apache_protec|Sécuriser Apache]] en limitant les accès aux répertoires. On peut pour cela utiliser les fichiers .htaccess ou modifier directement la configuration du serveur, généralement <code>/etc/apache/httpd.conf</code> ou <code>/etc/apache2/apache2.conf</code> .<br />
<br />
Utilisez [[Reseau-secu-ssh|ssh/sshd]] plutôt que <code>telnet</code>. En effet, ce dernier ne chiffre pas ses flux de données, contrairement à ssh, ce qui permet grâce à un simple sniffeur réseau de voler identifiants et mots de passe via le réseau.<br />
<br />
Les serveurs de fichiers (ou apparents) tels <code>Samba</code>, <code>NFS</code> ou encore <code>FTP</code> ne doivent accepter de connexion que des utilisateurs enregistrés : une section est prévue à cet effet dans le fichier de configuration de chaque serveur. Il est préférable de faire ceci, même si les services n'autorisent que les connexions locales et même si l'authentification des utilisateurs est déjà limitée : mieux vaut trop de sécurité que pas assez. Si vous cherchez à faire du transfert de fichiers de manière sécurisée, préférez <code>scp</code> (qui est en fait une manière d'utiliser le protocole ssh).<br />
<br />
Si vous utilisez vnc, préférez le faire de manière sécurisée : [[Reseau-resau_plus-vnc|vnc au-dessus de ssh]].<br />
<br />
== Barrer la route aux connexions non souhaitées ==<br />
Une fois limité les ports réseau attendant des connexions, il faut mettre en place un firewall filtrant grâce à iptables (ou autre). Netfilter est le nom de la couche du noyau qui permet de filtrer tout ce qui passe par les interfaces réseau, tandis que iptables est une interface permettant de piloter Netfilter. Ne pas confondre, donc.<br />
Des articles ont déjà été écrits à ce propos :<br />
* [[Reseau-secu-iptables|iptables par l'exemple]]<br />
* [[Reseau-secu-murdefeu|Mur de feu pas à pas]]<br />
* [[Leapro-pro_reseau-qos|QoS via iptables]]<br />
<br />
De manière très succincte, il faut fermer tous les ports puis ouvrir ceux dont on a besoin : le port 80 (et le 443 pour du https) doit être ouvert si l'on a un serveur web, le port 110 si l'on a un serveur pop dont on veut qu'il soit accessible d'internet, etc.<br />
<br />
Voici un bon script de base qu'on peut adapter :<br />
<code>#!/bin/sh<br />
# firewall v1.0.1 Oct 13 09:48:57 PDT 2003 written by : Kernel <kernel@trustonme.net><br />
# Modifié par merlin8282 (je ne sais plus où j'ai pioché l'original mais il y ressemble encore vraiment beaucoup).<br />
# this script is free software according to the GNU General Public License (see [www.gnu.org])<br />
# Start/stop/restart/status firewall:<br />
<br />
firewall_start() {<br />
<br />
echo "[Démarrage du firewall]"<br />
<br />
############################### REGLES PAR DEFAUT ###########################<br />
<br />
echo "[Initialisation de la table filter]"<br />
iptables -F<br />
iptables -X<br />
<br />
echo "[Politique par défaut de la table filter]"<br />
<br />
# On ignore tout ce qui entre ou transite par la passerelle<br />
iptables -P INPUT DROP<br />
iptables -P FORWARD DROP<br />
<br />
# On accepte, ce qui sort<br />
iptables -P OUTPUT ACCEPT<br />
<br />
# Pour éviter les mauvaises suprises, on va autoriser l'accès à la loopback :<br />
iptables -A INPUT -i lo -j ACCEPT<br />
iptables -A OUTPUT -o lo -j ACCEPT<br />
<br />
############################### LOCAL-INTERNET ###########################<br />
<br />
echo "[On autorise les clients à accéder à internet]"<br />
<br />
#On créé une nouvelle chaîne, le nom est indifférent<br />
# appelons-la "local-internet"<br />
iptables -N local-internet<br />
<br />
# On définit le profil de ceux qui appartiendront à "local-internet"<br />
# "local-internet" concerne toutes les connections sauf celles venant d'internet ( ! = non)<br />
# En gros avec ça, vous rendez, vos serveurs inaccessibles depuis internet.<br />
# Pas de panique, certains serveurs seront autorisés explicitement dans la suite.<br />
# (Remplacer ppp0 en fonction de votre configuration)<br />
iptables -A local-internet -m state --state NEW -i ! ppp0 -j ACCEPT<br />
<br />
#Evidemment, une fois acceptées comme "local-internet", les connections peuvent continuer<br />
# et faire des petits :<br />
iptables -A local-internet -m state --state ESTABLISHED,RELATED -j ACCEPT<br />
<br />
# On termine en indiquant que les connections appartenant à "local-internet"<br />
# accèdent à internet de manière transparente.<br />
iptables -A INPUT -j local-internet<br />
iptables -A FORWARD -j local-internet<br />
<br />
############################### LES TABLES NAT ET MANGLE #############################<br />
<br />
echo "[Initialisation des tables nat et mangle]"<br />
<br />
iptables -t nat -F<br />
iptables -t nat -X<br />
iptables -t nat -P PREROUTING ACCEPT<br />
iptables -t nat -P POSTROUTING ACCEPT<br />
iptables -t nat -P OUTPUT ACCEPT<br />
<br />
iptables -t mangle -F<br />
iptables -t mangle -X<br />
iptables -t mangle -P PREROUTING ACCEPT<br />
iptables -t mangle -P OUTPUT ACCEPT<br />
<br />
############################### LE MASQUERADING #########################<br />
<br />
# Commentez ces 2 lignes, si vous ne faîtes pas du masquerading (nat)<br />
#echo "[Mise en place du masquerading]"<br />
#iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o ppp0 -j MASQUERADE<br />
<br />
########################### ACTIVATION DE LA PASSERELLE ##################<br />
<br />
#echo "[Activation de la passerelle]"<br />
#echo 1 > /proc/sys/net/ipv4/ip_forward<br />
<br />
############################## PAS DE SPOOFING ##########################<br />
<br />
echo "[Pas de spoofing]"<br />
if [ -e /proc/sys/net/ipv4/conf/all/rp_filter ] ; then<br />
for filtre in /proc/sys/net/ipv4/conf/*/rp_filter<br />
do<br />
echo 1 > $filtre<br />
done<br />
fi<br />
<br />
########################## PAS DE SYNFLOOD ####################<br />
<br />
echo "[Pas de synflood]"<br />
if [ -e /proc/sys/net/ipv4/tcp_syncookies ] ; then<br />
echo 1 > /proc/sys/net/ipv4/tcp_syncookies<br />
fi<br />
<br />
############################### PAS DE PING ############################<br />
<br />
# commentez ces 6 lignes, si vous autorisez les pings sur votre passerelle<br />
echo "[Pas ping]"<br />
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all<br />
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts<br />
if [ -e /proc/sys/net/ipv4/icmp_ignore_bogus_error_responses ] ; then<br />
echo 1 > /proc/sys/net/ipv4/icmp_ignore_bogus_error_responses<br />
fi<br />
<br />
############# Priorisation de la bande passante et des connections - QoS ############<br />
<br />
echo "[priorisation des connections ssh ...]";<br />
iptables -A PREROUTING -t mangle -p tcp --sport 443 -j TOS --set-tos Minimize-Delay<br />
<br />
echo "[priorisation des connections http ...]";<br />
iptables -A PREROUTING -t mangle -p tcp --sport http -j TOS --set-tos Maximize-throughput<br />
iptables -A PREROUTING -t mangle -p tcp --sport 3129 -j TOS --set-tos Maximize-throughput<br />
<br />
############################ Fonctionnalités serveurs #####################################<br />
<br />
echo "[Etude des fonctionalités serveurs, visibles depuis internet]"<br />
<br />
# A ce stade, tous vos clients du réseau local et de la passerelle ont accès à internet. Mieux,<br />
# vos clients du réseau local, ont accès à vos serveurs apache, proftp ... localement. Mais personne<br />
# depuis internet ne peux accéder à l'un des serveurs que vous hébergez.<br />
<br />
# Il est bien-sûr possible de dévérrouiller pontuellement l'accès à un serveur depuis internet,<br />
# en décommentant les 2 ou 3 lignes correspondantes.<br />
<br />
#echo "[autorisation du serveur ssh(22) ...]"<br />
#iptables -A INPUT -p tcp --dport ssh -j ACCEPT<br />
<br />
#echo "[autorisation du serveur smtp(25) ...]"<br />
#iptables -A INPUT -p tcp --dport smtp -j ACCEPT<br />
<br />
#echo "[autorisation du serveur http(80) ...]"<br />
#iptables -A INPUT -p tcp --dport www -j ACCEPT<br />
<br />
#echo "[autorisation du serveur https(443) ...]"<br />
#iptables -A INPUT -p tcp --dport 443 -j ACCEPT<br />
<br />
#echo "[autorisation du serveur DNS(53) ...]"<br />
#iptables -A INPUT -p udp --dport domain -j ACCEPT<br />
#iptables -A INPUT -p tcp --dport domain -j ACCEPT<br />
<br />
#echo "[autorisation du serveur irc(6667) ...]"<br />
#iptables -A INPUT -p tcp --dport ircd -j ACCEPT<br />
<br />
#echo "[autorisation du serveur cvs (2401) ...]"<br />
#iptables -A INPUT -p tcp --dport cvspserver -j ACCEPT<br />
<br />
#echo "[autorisation du serveur FTP(21 et 20) ...]"<br />
#iptables -A INPUT -p tcp --dport ftp -j ACCEPT<br />
#iptables -A INPUT -p tcp --dport ftp-data -j ACCEPT<br />
<br />
# Ne pas décommenter les 3 lignes qui suivent.<br />
# Plus généralement :<br />
#echo "[autorisation du serveur Mon_truc(10584) ...]"<br />
#iptables -A INPUT -p tcp --dport 10584 -j ACCEPT<br />
<br />
#echo "[autorisation du serveur aMule (4662/tcp) ...]"<br />
#iptables -A INPUT -p tcp --dport 4662 -j ACCEPT<br />
<br />
#echo "[autorisation du serveur BitTorrent (6881-6889/tcp) ...]"<br />
#iptables -A INPUT -p tcp --dport 6881:6889 -j ACCEPT<br />
<br />
echo "[firewall activé !]"<br />
}<br />
<br />
firewall_stop() {<br />
<br />
<br />
iptables -F<br />
iptables -X<br />
iptables -P INPUT ACCEPT<br />
iptables -P FORWARD ACCEPT<br />
iptables -P OUTPUT ACCEPT<br />
<br />
iptables -t nat -F<br />
iptables -t nat -X<br />
iptables -t nat -P PREROUTING ACCEPT<br />
iptables -t nat -P POSTROUTING ACCEPT<br />
iptables -t nat -P OUTPUT ACCEPT<br />
<br />
iptables -t mangle -F<br />
iptables -t mangle -X<br />
iptables -t mangle -P PREROUTING ACCEPT<br />
iptables -t mangle -P OUTPUT ACCEPT<br />
<br />
echo " [firewall descativé!]"<br />
}<br />
<br />
firewall_restart() {<br />
firewall_stop<br />
sleep 2<br />
firewall_start<br />
}<br />
<br />
case "$1" in<br />
'start')<br />
firewall_start<br />
;;<br />
'stop')<br />
firewall_stop<br />
;;<br />
'restart')<br />
firewall_restart<br />
;;<br />
'status')<br />
iptables -L<br />
iptables -t nat -L<br />
iptables -t mangle -L<br />
;;<br />
*)<br />
echo "Usage: firewall {start|stop|restart|status}"<br />
esac</code><br />
Ce script est à mettre généralement dans un fichier du dossier <code>/etc/init.d/</code> .<br />
<br />
== Détecter les intrusions, connaître les outils ==<br />
=== who ===<br />
La commande <code>who</code> ou <code>w</code> permet de voir les utilisateurs actuellement connectés (loggés) au système. Attention cependant car un agresseur peut être -- et l'est certainement si c'est le cas -- connecté sous votre nom, s'il est parvenu à s'immiscer dans votre système.<br />
<br />
=== ps ===<br />
La commande <code>ps</code> liste tous les processus actuellement en cours d'exécution sur le système. S'il en est un que vous ne connaissez pas, identifiez-le. Si vous ne savez toujours pas ce que c'est, pas d'affollement : utilisez la commande <code>lsof</code> et voyez si vous trouvez des fichiers en rapport avec ce processus. Vous pouvez alors identifier le processus et déterminer si c'est un processus "inoffensif". Si ce n'est pas le cas, vous pouvez supprimer les fichiers qu'il faut. Attention toutefois à bien être certain que ce soit un logiciel malveillant que vous supprimez ! En revanche, si c'est un logiciel qui s'est fait infecter (par exemple apache) il suffit de réinstaller celui-ci, après avoir vidé le cache des paquets de votre gestionnaire de packages. Vérifiez aussi la configuration après réinstallation. Nul besoin de redémarrer, sauf si évidemment c'est le noyau qui est corrompu, chose qui est à mon avis très rare.<br />
<br />
=== netstat ===<br />
La commande <code>netstat</code> est une commande qui liste toutes les connexions réseau actives sur votre machine ainsi que l'état dans lequel elles sont (listening, connected, established, etc.) :<br />
<code>Proto Recv-Q Send-Q Adresse locale Adresse distante Etat<br />
tcp 0 0 0.0.0.0:3129 0.0.0.0:* LISTEN<br />
tcp6 0 0 :::443 :::* LISTEN</code><br />
On voit ici par exemple que le port 3129 écoute (LISTEN) sur la machine locale (0.0.0.0) et que le port 443 en fait de même.<br />
Vérifiez les connexions actives, les ports ouverts, et faites le lien avec vos démons et autres programmes qui tournent. Si un port ne vous dit rien, informez-vous.<br />
<br />
=== lsof ===<br />
La commande <code>lsof</code> liste tous les fichiers ouverts actuellement. Elle indique aussi quel utilisateur utilise quel fichier.<br />
<code>COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME<br />
init 1 root mem REG 3,65 31432 1720343 /sbin/init<br />
apache2 597 root mem REG 3,65 385484 25423 /usr/sbin/apache2</code><br />
Les informations parlent d'elle-mêmes. Ce sont deux cas précis parce-que le processus <code>init</code> a le fichier <code>/sbin/init</code> d'ouvert (de même pour apache).<br />
<br />
=== fcheck ===<br />
C'est un utilitaire qui notifie l'administrateur en cas de modification de fichiers. On précise dans le fichier de configuration quels fichiers ou dossiers on veut surveiller et un mail est envoyé en cas de changement.<br />
<br />
=== logcheck ===<br />
<code>logcheck</code> est un outil qui scrute les logs, en fait un résumé et envoie un courriel à l'administrateur (généralement root en local) régulièrement. Evidemment, il est possible de configurer le niveau de ce qui est rapporté.<br />
<br />
=== chkrootkit ===<br />
C'est un logiciel important, puisqu'il détecte la présence de rootkits. Son principe de fonctionnement est l'écoute des ports réseau. Relativement souvent, cependant, des logiciels tels les clients peer2peer sont détectés comme une menace, bien qu'ils soient innofensifs. En effet, ils utilisent des ports qui ne sont pas "officiellement" connus (contrairement au port 80, par exemple, qui est celui de tout serveur web). Donc pas d'affollement.<br />
<br />
== Localiser le problème et nettoyer ==<br />
Grâce aux outils précédents il est plus ou moins facile de localiser d'où vient le problème. On peut alors agir en conséquence, à savoir tuer les processus incriminés et supprimer les logiciels correspondants. Au préalable on peut aussi, si l'on est curieux, regarder ce qu'a fait l'attaquant : il a certainement laissé des traces que l'on peut examiner pour mieux comprendre.<br />
<br />
L'intrus ayant pu avoir les droits root il serait de bon augure de réinstaller proprement -- en ayant pris soin de vider le cache de son gestionnaire de paquets -- les outils permettant la découverte de logiciels non souhaités, comme chkrootkit. Ceci fait un scan complet de tous les disques doit être fait. Prenez soin de monter toutes les partitions avant de lancer le scan. Veillez aussi à vérifier le partitionnement de vos disques, au cas où l'attaquant aurait créé une partition dans le but d'avoir un endroit de stockage de ses outils malveillants que l'administrateur de la machine -- vous-même -- ne verrait pas. Eh oui, il faut penser à toutes les éventualités ! Je pense qu'il vaut mieux être trop paranoïaque que pas assez, lorsqu'on administre un serveur.<br />
<br />
Lors de la possible compromission de la machine, il faut considérer les commandes sensibles (ps, top, who...) comme compromises.<br />
Un LiveCD peut dans le cadre d'une machine personnelle vous fournir une base de commandes saines.<br />
Dans le cadre d'une machine en production (serveur) qui ne doit souffrir de l'arrêt des services, un jeu de commandes compilées (avec librairie statique) sur un support extérieur (CD, clef USB...) peut être nécessaire.<br />
<br />
== Voir aussi ==<br />
* [http://fr.wikipedia.org/wiki/Cat%C3%A9gorie:Logiciel_de_s%C3%A9curit%C3%A9_informatique Wikipédia : Catégorie:Logiciel de sécurité informatique]<br />
* [http://fr.wikipedia.org/wiki/S%C3%A9curit%C3%A9_informatique Wikipédia : Sécurité des systèmes d'information]<br />
* [http://fr.wikipedia.org/wiki/Risques_en_s%C3%A9curit%C3%A9_informatique Wikipédia : Risques en sécurité informatique]<br />
* [http://www.debian.org/doc/manuals/securing-debian-howto/index.fr.html Une excellente documentation concernant la sécurisation de la distribution Debian GNU/Linux]<br />
<br />
== Conclusion ==<br />
Même si l'on connaît les risques, il est toujours impératif de rester sur ses gardes. De nouvelles menaces apparaissent régulièrement, de nouvelles failles sont découvertes chaque jour, de nouveaux virus aussi, etc. L'avenir nous dira si un jour on aura des ordinateurs sûrs à 100%, chose qui n'est pas impossible mais cependant improbable.<br />
<br />
== Remerciements ==<br />
Un grand merci à abgech pour sa contribution à la partie concernant le BIOS,<br><br />
Merci à oudoubah, pour ses idées et son expérience,<br><br />
Merci à Morgan pour l'aide qu'il m'a apporté pour restructurer l'article, ainsi que pour ses idées et ses critiques également.<br><br />
Merci à Fleury pour avoir contribué grandement à l'article (''sécurité réseau'' et ''sécurité logicielle'', ainsi qu'une certaine restructuration de l'article)<br><br />
Merci enfin à Léa d'être là pour le logiciel libre !<br />
<br />
{{Copy|2006|[[Utilisateur:Merlin8282|Merlin8282]], [[Utilisateur:Fleury|Fleury]]|CC-BY-NC-SA}}</div>Esahttps://lea-linux.org/docs/index.php?title=DCOP&diff=12968DCOP2006-07-06T21:27:52Z<p>Esa : /* amarok */</p>
<hr />
<div>[[Category:Développer sous Linux]]<br />
= Présentation de DCOP =<br />
<br />
<div class="leatitre">Présentation de DCOP</div><div class="leapar">par Teotihuacan</div><div class="leadesc">Ceci est une courte présentation de DCOP.</div><br />
<br />
== Présentation ==<br />
<br />
DCOP (Desktop COmmunication Protocol) est un service interne à KDE permettant de communiquer avec les applications KDE. Vous allez donc pouvoir communiquer avec ces applications grâce à votre shell. Cela inclut la récupération d'informations, ou la demande d'exécution d'actions à ces applications.<br />
<br />
DCOP est intégré aux librairies de KDE. Vous n'avez pas à vous soucier de l'installation et de la configuration de DCOP. Si vous avez installé Kdelib (une version au moins égale à 2.0) sur votre distribution, il se lancera automatiquement.<br />
<br />
Les programmeurs d'une application KDE ne sont pas obligés d'utiliser DCOP. Mais cela constitue certainement un plus. Pour une application, un programmeur aura donné la possibilité à l'utilisateur de faire un certain nombre d'appels.<br />
<br />
Quant à la nature des appels DCOP que l'utilisateur final pourra faire à partir de son shell, il s'agit ni plus ni moins que de fonctions, avec tout ce que cela implique : une fonction a un nom, des arguments et un résultat. L'utilisateur fera appel à la fonction grâce au nom de la fonction, et en fonction des arguments qu'il aura entré, la fonction lui retournera un résultat. Ce résultat peut être une information affichée et/ou une action que va effectuer le programme.<br />
<br />
== Utilisation ==<br />
<br />
Nous allons ici aborder la façon dont l'utilisateur va pouvoir communiquer avec le service DCOP à partir de son shell. L'utilisation de DCOP est très simple, elle se fait par la commande <code>dcop</code>.<br />
<br />
La syntaxe pour faire un appel à une fonction est la suivante :<br />
<br />
<div class="code">$ dcop APPLICATION INTERFACE FONCTION ARGUMENTS</div><br />
<br />
{|<br />
| Avec<br />
| width="10px" | <br />
| APPLICATION<br />
| width="10px" | <nowiki>:</nowiki><br />
| C'est le nom de l'application que l'on vise.<br />
|-<br />
| <br />
| width="10px" | <br />
| INTERFACE<br />
| width="10px" | <nowiki>:</nowiki><br />
| Les fonctions DCOP d'une application sont regroupées par interface.<br />
|-<br />
| <br />
| width="10px" | <br />
| FONCTION<br />
| width="10px" | <nowiki>:</nowiki><br />
| C'est le nom de la fonction que l'on souhaite appeler.<br />
|-<br />
| <br />
| width="10px" | <br />
| ARGUMENTS<br />
| width="10px" | <nowiki>:</nowiki><br />
| Ce sont les arguments que l'on souhaite passer à la fonction. Il peut y en avoir un, plusieurs ou aucun. S'il y a plusieurs arguments, il suffit de les séparer par un espace.<br />
|}<br />
<br />
Mais heureusement, vous n'êtes pas obligés de connaître toutes ces informations par c&oelig;ur.<br />
<br />
* Si vous entrez juste <code>dcop</code>, vous obtiendrez la liste des applications qui ont ouvert une interface DCOP.<br />
* Si vous entrez alors <code>dcop APPLICATION</code>, vous obtiendrez la liste des interfaces DCOP disponibles pour cette application. Les applications sont désignées par leur nom.<br />
* Si vous entrez maintenant <code>dcop APPLICATION INTERFACE</code>, vous obtiendrez la liste des fonctions qui sont à votre disposition pour cette interface. Et pour chaque fonction, vous obtiendrez le type de résultat auquel vous devez vous attendre et les arguments nécessaires pour la fonction : c'est le prototype de la fonction. Il se présente sous la forme : <code>TYPE_RETOURNÉ '''NOM_FONCTION('''TYPE_DES_ARGUMENTS''')'''</code>.<br />
<br />
<div class="alert">Certaines applications peuvent avoir plusieurs instances, par exemple Konqueror et Kwrite, Pour désigner l'application avec dcop, il faut faire suivre le nom de l'application d'un tiret et de son PID. Ainsi, dans la liste des applications accessibles par DCOP, on pourra retouver un "konqueror-7327" et un "konqueror-5837" par exemple.</div><br />
<br />
== Exemple ==<br />
<br />
Maintenant que je vous ai présenté le fonctionnement basique de DCOP, il est temps de passer à la pratique avec un exemple.<br />
<br />
=== kwin ===<br />
<br />
Ouvrez une console sur KDE.<br />
<br />
Entrer la commande <code>dcop</code> pour afficher la liste des applications accessibles. Vous obtiendrez alors une liste telle que celle-ci :<br />
<br />
<div class="code">$ dcop<br /> KWeatherService<br /> konsole-7205<br /> kwin<br /> kicker<br /> amarok<br /> kded<br /> knotify<br /> kio_uiserver<br /> kcookiejar<br /> konqueror-7327<br /> rssservice<br /> korgac<br /> konsole-7165<br /> klauncher<br /> khotkeys<br /> kopete<br /> kdesktop<br /> korn<br /> klipper<br /> ksmserver<br /> konqueror-5837</div><br />
<br />
Pour utiliser une application que tout le monde a, essayons avec KWin (le gestionnaire de fenêtres de KDE). Affichons maintenant les interfaces DCOP ouvertes pour KWin :<br />
<br />
<div class="code">$ dcop kwin<br /> qt<br /> KWinInterface (default)<br /> MainApplication-Interface</div><br />
<br />
Voyons alors les fonctions de "KWinInterface" :<br />
<br />
<div class="code">$ dcop kwin KWinInterface<br /> QCStringList interfaces()<br /> QCStringList functions()<br /> ASYNC cascadeDesktop()<br /> ASYNC unclutterDesktop()<br /> ASYNC reconfigure()<br /> ASYNC killWindow()<br /> void refresh()<br /> void doNotManage(QString)<br /> void showWindowMenuAt(unsigned long int winId,int x,int y)<br /> void setDesktopLayout(int orientation,int x,int y)<br /> bool setCurrentDesktop(int)<br /> int currentDesktop()<br /> void nextDesktop()<br /> void previousDesktop()<br /> void circulateDesktopApplications()</div><br />
<br />
Intéressons-nous dans un premier temps à la fonction <code>int currentDesktop()</code>. Pour ceux qui ne sont pas habitués à ce type de syntaxe (que l'on retrouve en C par exemple), le <code>int</code> représente le résultat de la fonction. Là, c'est un entier. Entre les parenthèses, il n'y a rien, ça veut donc dire qu'il n'y a pas d'argument à transmettre à la fonction. Il ne reste plus qu'à tester :<br />
<br />
<div class="code">$ dcop kwin KWinInterface currentDesktop<br /> 4</div><br />
<br />
La fonction m'a donc retourné un <code>4</code>. Il n'y a pas de description pour cette fonction, mais son nom est assez explicite : on imagine bien qu'elle m'a renvoyé le numéro du bureau sur lequel j'étais, en l'occurence le bureau 4.<br />
<br />
Essayons maintenant la fonction <code>void nextDesktop()</code> de cette même interface. Le <code>void</code> au début m'informe que cette fonction ne renvoie rien. Je m'attends donc à ce que l'appel de cette fonction effectue une action plutôt que de renvoyer une information. Ainsi, en entrant la commande :<br />
<br />
<div class="code">$ dcop kwin KWinInterface nextDesktop</div><br />
<br />
Je me retrouve sur le bureau suivant, dans mon cas soit le 5, soit le 1 (les bureaux tournent en boucle, si le 4 est mon dernier, je reviens au 1). Encore une fois, le nom de la fonction est assez explicite.<br />
<br />
Essayons maintenant une fonction avec un argument : <code>bool setCurrentDesktop(int)</code>. Comme vous l'imaginez, cette fonction va permettre d'afficher le bureau que l'on souhaite. Le <code>bool</code> au début m'informe que la fonction va me renvoyer un booléen, soit VRAI (true) ou FAUX (false). Vraisemblablement, le "VRAI" est obtenu si le changement a pu s'effectuer. Entre les parenthèses, il y a cette fois un <code>int</code>, c'est l'argument que l'on doit donner à la fonction. Ici, c'est donc un entier. Vous imaginez bien que cet entier va représenter le bureau que l'on souhaite afficher. Ainsi, pour afficher le bureau 2 :<br />
<br />
<div class="code">$ dcop kwin KWinInterface setCurrentDesktop 2</div><br />
<br />
=== amarok ===<br />
<br />
Amarok ''LE'' lecteur de musique pour KDE est pratiquement entièrement controlable via l'interface DCOP. Voici quelques exemples.<br />
<br />
On vide la playlist d'Amarok :<br />
<code multi>$ dcop amarok playlist clearPlaylist<br />
</code><br />
On ajoute tous les fichiers <code>ogg</code> à la playlist :<br />
<code multi>$ for i in *.ogg ; do dcop amarok playlist addMedia file:`pwd`/$i ; done<br />
</code><br />
'''PS:''' on utilise ici une facilité du shell qui permet de remplacer une commande par le résultat de son exécution <code>`pwd`</code> (attention, ce sont bien des apostrophes inverses obtenues par <key>ALTGR+7</key>). Cette syntaxe est désormais rendue désuette par son nouvel homologue: <code>$(commande)</code>.<br />
<br />
On joue la piste 5 de la playlist :<br />
<code multi>$ dcop amarok playlist playByIndex 5</code><br />
<br />
Et caetera !<br />
<br />
== KDCOP ==<br />
<br />
KDCOP est une application KDE qui répertorie toutes les entrées DCOP actives. Vous pouvez vous y référer pour visualiser facilement les appels que vous pouvez faire. Cette application est accessible en lançant la commande <code>kdcop</code>.<br />
<br />
En plus de visualiser la liste des entrées possibles, vous pouvez y faire directement vos appels.<br />
<br />
[[Image:dcop-dcop_kdcop.png]]<br />KDCOP en action<br />
<br />
== Application ==<br />
<br />
Vous allez pouvoir utiliser les possibilités de DCOP à plusieurs niveaux :<br />
<br />
* Vous allez pouvoir inclure ce genre de communication dans vos propres applications KDE. Pour cela, je vous renvoie à [http://developer.kde.org/documentation/library/cvs-api/dcop/html/index.html La Documentation de l'API].<br />
* Cela vous permet d'étendre les possibilités de vos scripts en pilotant les applications KDE. Par exemple, pour Amarok (lecteur multimédia de KDE), rien ne vous empêche de créer un script qui, en fonction du pourcentage de la piste lue, revient soit au début de la chanson, soit à la chanson précédente. Ça peut aussi être utilisé quand on configure les touches multimédia de son clavier.<br />
* Kommander : c'est une application qui permet à partir d'une interface de lier des commandes shell. Kommander est une application qui repose beaucoup sur DCOP, car la communication entre les différents composants de l'interface est assurée par DCOP. Pour plus de détails, je vous renvoie à [http://www.kde-apps.org/content/show.php?content=12865 la page de Kommander sur KDE-Apps.org].<br />
<br />
== Sources ==<br />
<br />
[http://www-106.ibm.com/developerworks/linux/library/l-dcop/?ca=dgr-kdeml01KDEDCOP IBM Developperwork : DCOP]<br />
<br />
<div class="merci">Cette page est issue de la documentation 'pré-wiki' de Léa a été convertie avec HTML::WikiConverter. Elle fut créée par Teotihuacan le 29/12/2004.</div><br />
<br />
{{Copy|29/12/2004|Teotihuacan|CC-BY-NC-SA}}</div>Esa