Differences

This shows you the differences between two versions of the page.

--- admin:index [2016/03/11 09:07] – [Administration des Réseaux] orel
+++ admin:index [2024/03/18 15:06] (current) – external edit 127.0.0.1
@@ Line 6: / Line 6: @@
   * [[admin:tp1|TP1 (prise en main)]]
-  * [[admin:tp2|TP2 (scapy)]]
+  * [[admin:tp2|TP2 (routage)]]
-  * [[admin:tp3|TP3 (routage)]]
+  * [[admin:tp3|TP3 (Scapy et Divers Trucs)]] + [[rx:tp5-bonus|Connexion TCP en Scapy]]
-  * [[admin:tp4|TP4 (nat)]]
+  * [[admin:tpvlan|TP VLAN]]
-  * [[admin:tp5|TP5 (firewall)]]
+  * [[admin:tp4|TP4 (NAT)]]
-  * [[admin:tp6|TP6 (nis/nfs]]
+  * [[admin:tp5|TP5 (firewall)]]
-  * [[admin:tp7|TP7 (ldap)]]
+  * [[admin:tpipv6|TP IPv6]]
-  * [[admin:tp8|TP8]]
+  * [[admin:tp6|TP6 (NIS & NFS)]]
-  * [[admin:tp9|TP9]]
+  * [[admin:tp7|TP7 (LDAP)]]
+  * [[admin:tp8|TP8 (DNS & DHCP)]]
+  * [[admin:tp9|TP9 (Windows)]]
 Pour tester les TPs sur votre machine, c'est [[admin:qemunet-ar | ici]]
-==== TP1 ====
+Console Qemu : Ctrl-A + C puis system_reset pour reboot une machine.
-Lancez le réseau virtuel avec QEMU. Entrez le login //root//, il n'a pas de //password//.
-Pour configurer deux machines dans le réseau local 192.168.0.0/24 :
-  immortal$ ifconfig -a
-  immortal$ ifconfig eth0 192.168.0.1/24
-  immortal$ ifconfig eth0 192.168.0.1 netmask 255.255.255.0    # même chose
-  opeth$ ifconfig eth0 192.168.0.2/24
-  opeth$ ping 192.168.0.1
-Avec le fichier de configuration /etc/network/interfaces :
-<code bash /etc/network/interfaces>
-# loopback
-auto lo
-iface lo inet loopback
-# interface eth0
-auto eth0
-iface eth0 inet static
-address 192.168.0.1
-netmask 255.255.255.0
-</code>
-On recharge la configuration :
-  $ /etc/init.d/networking restart
-Enjoy !
-==== TP2 (Routage) ====
-__Memento__
-  * Activer le routage sur une machine (ip forward) : ''echo 1 > /proc/sys/net/ipv4/ip_forward'' ou ''sysctl -w net.ipv4.ip_forward=1''
-  * Afficher la table de routage : ''route -n''
-  * Définir une route par défaut : ''route add default gw <@gateway>''
-  * Ajouter une route vers un réseau : ''route add -net <@network> netmask <mask> gw <@gateway>''
-  * Ajouter une route vers une machine particulière : ''route add -host <@host> gw <@gateway>''
-  * Pour supprimer une règle, il taper la commande ''route del <...>'' avec exactement les mêmes arguments que pour la commande ''add''.
-__Routage__
-Considérons le réseau 147.210.0.0/16 (cf. TP2) avec les configurations suivantes :
-    opeth (eth0,13.1) --- (eth0,13.2) immortal (eth1,12.2) ---
-                                                             |
-                                                         grave (eth1,14.1)
-                                                             |
-          nile (eth0,16.2) --- (eth1,16.1) syl (eth0,14.2) ---
-Voici un résumé des commandes à taper sur chaque machine pour que toutes communiquent !
-<code>
-opeth$ ifconfig eth0 147.210.13.1/24
-opeth$ route add default gw 147.210.13.2
-nile$ ifconfig eth0 147.210.16.2/24
-nile$ route add default gw 147.210.16.1
-immortal$ ifconfig eth0 147.210.13.2/24
-immortal$ ifconfig eth1 147.210.12.2/24
-immortal$ route add default gw 147.210.12.1
-immortal$ echo 1 > /proc/sys/net/ipv4/ip_forward
-syl$ ifconfig eth0 147.210.14.2/24
-syl$ ifconfig eth1 147.210.16.1/24
-syl$ route add default gw 147.210.14.1
-syl$ echo 1 > /proc/sys/net/ipv4/ip_forward
-grave$ ifconfig eth0 147.210.12.1/24
-grave$ ifconfig eth1 147.210.14.1/24
-grave$ route add -net 147.210.13.0/24 gw 147.210.12.2
-grave$ route add -net 147.210.16.0/24 gw 147.210.14.2
-grave$ echo 1 > /proc/sys/net/ipv4/ip_forward
-</code>
-En cas de problème, il faut effectuer un diagnostic avec les commandes //ping// et //tcpdump -i any//. Lorsqu'on indique une //gateway//, il faut que cette machine soit accessible directement via une route locale.
-__ARP__
-Pour afficher le cache ARP, il suffit de taper la commande //arp -n//.
-__Wireshark__
-Pour utiliser Wireshark depuis en exportant une capture depuis la machine virtuelle //immortal// :
-<code>
-immortal$ mount /mnt/host -o remount,rw
-immortal$ tcpdump -i eth0
-immortal$ tcpdump -i eth0 -s 1500 -w /mnt/host/capture
-immortal$
-</code>
-Votre fichier //capture// se trouve dans le répertoire UML-TMP/immortal/ de votre machine hôte. Lancez Wireshark, ouvrez votre capture. Sélectionner la trame TCP qui vous intéresse et cliquez avec le bouton-droit sur "Follow TCP Stream" pour afficher tous les échanges associés à une connexion.
-==== TP3 (Scapy et Divers Trucs) ====
-__Scapy__
-Un peu de Scapy avec l'interpréteur de commande en langage Pyhthon. Lancez la commande "scapy" dans un shell root.
-Voici un exmple pour construire un message de type ICMP/IP Echo-Request (ping). La fonction show() montre le contenu des headers & payloads pour ce message.
-<code python>
-$ scapy
-Welcome to Scapy (2.2.0)
->>> ping = IP(dst='192.168.0.2')/ICMP()
->>> ping.show()
-###[ IP ]###
-  version= 4
-  ihl= None
-  tos= 0x0
-  len= None
-  id= 1
-  flags=
-  frag= 0
-  ttl= 64
-  proto= icmp
-  chksum= None
-  src= 192.168.0.1
-  dst= 192.168.0.2
-  \options\
-###[ ICMP ]###
-     type= echo-request                            # valeur par défaut (ping)
-     code= 0
-     chksum= None
-     id= 0x0
-     seq= 0x0
->>>
-</code>
-Même chose avec un message TCP/IP à destination de 192.168.0.1 (port 80) avec le flag TCP SYN (demande d'ouverture de connexion). La fonction sr1() permet d'effectuer un envoi/réception...
-<code python>
->>> x=IP(dst="192.168.0.1")/TCP(flags="S",dport=80)    # on forge un paquet TCP/IP
->>> x.show()
->>> y = sr1(x)                                         # send/receive
->>> y.show()
-</code>
-Voici un exemple de script //Scapy// pour faire un traceroute.
-<code python traceroute.py>
-#!/usr/bin/env python
-import sys
-from scapy.all import *
-def mytraceroute(target,maxttl):
-  for x in range(maxttl):
-    rsp = sr1(IP(dst=target, ttl=x)/ICMP(),verbose=0)
-    if rsp.getlayer(ICMP).type==11 and rsp.getlayer(ICMP).code==0:
-      print rsp.src
-mytraceroute("10.0.0.2",8)
-</code>
-Un autre script //Scapy// pour faire un Syn Scan.
-<code python synscan.py>
-#!/usr/bin/env python
-import sys
-from scapy.all import *
-def synscan(host):
-   ports = range(1000)
-   ip = IP(dst=host)
-   tcp = TCP(dport=ports,flags="S")
-   ans,unans = sr(ip/tcp)
-   for sent,rcvd in ans:
-      if rcvd.haslayer(TCP):
-         # if rcvd.getlayer(TCP).flags & 2:
-         if rcvd.sprintf("%TCP.flags%") == 'SA':
-            print sent.dport
-synscan("192.168.0.1")
-</code>
-Une autre version avec un XMAS scan...
-<code python xmasscan.py>
-#!/bin/python
-from scapy.all import *
-ports = range(1,1000)
-ipdst = "10.0.0.2"
-for i in ports:
-	pkt=IP(dst=ipdst)/TCP(dport=i, flags="PUF")
-	a = sr1(pkt, verbose=False, timeout=0.1)
-	if a is None:
-		print '{} is open'.format(i)
-</code>
-Pour finir avec la connexion TCP/IP, c'est ici : https://samsclass.info/124/proj11/proj18-scapy-tcp.html
-__Telnet__
-Ouverture d'une connexion TCP/IP avec Telnet vers un serveur web sur immortal.
-<code>
-$ telnet @immortal 80
-  GET / HTTP/1.0  # enter
-                  # enter again
-  # la réponse HTTP du serveur web...
-  HTTP/1.1 200 OK
-  ...
-  ...
-</code>
-Pour sortir d'un Telnet, tapez "Ctrl-]".
-__ HTTP Connect__
-Considérons une machine A qui souhaite ouvrir une session telnet (port 23) sur une machine C en utilisant une connexion "rebond" sur un serveur web B (configuré pour autoriser le mode //proxy//).
-<code>
-A$ telnet @B 80
-  CONNECT @C:23 HTTP/1.0  # enter
-                  # enter again
-  C$login: xxxxxx
-  C$password:  xxxxxxx
-  C$ ...
-</code>
-__Attaque Man-in-the-Middle__
-Dans un LAN, //syl// souhaite intercepter les échanges entre //nile// et //immortal//.
-<code>
-syl$ arpspoof -i eth0 -t @immortal @nile  &> /dev/null &
-syl$ arpspoof -i eth0 -t @nile @immortal &> /dev/null &
-syl$ echo 1 > /proc/sys/net/ipv4/ip_forward                 # on active le routage
-syl$ tcpdump -i eth0 not arp                                # on ignore l'ARP
-syl$ pkill -9 arpspoof                                      # on fait le ménage à la fin !!!
-</code>
-__ Un peu de nmap__
-Le principe est relativement simple. Si l'on envoit en paquet TCP/IP avec le flag SYN (demande d'ouverture de connexion) sur un port donné, alors si un service écoute sur ce port, il nous répond SYN/ACK pour accépter la connexion. On en déduit que le port est ouvert. En revanche, si aucun serveur n'écoute sur ce port, le paquet est ignoré par le noyau. Autre cas possible. Si l'on envoi un paquet invalide, c'est-à-dire un paquet en dehors de toute connexion et sans flag SYN (ex. NULL, XMAS, ...), alors ce paquet est ignoré si un service est présent. En revanche, s'il n'y a pas de service à l'acoute sur le port cible, alors le noyau répond RST (reset). Ce qui nous permet de déduire que le port est effectivement fermé. A l'inverse, les autres ports sont supposés ouverts (ou filtrés).
-En résumé, voici les réponses dans les différents cas de figure :
-| | **Envoi paquet avec SYN** | **Envoi paquet invalide sans SYN** |
-| **Service à l'écoute** | SYN/ACK | ignoré |
-| **Pas de service(*)** | ignoré | RST |
-(*) Réponse du noyau.
-Quelques exemples de //scan// simples :
-<code>
-#ping scan
-$ nmap -sP 192.168.0.1-10
-#syn scan
-$ nmap -sS -p 21,22,80 192.168.0.1
-#xmas scan
-$ nmap -sX -p 4000-10000 192.168.0.1
-#traceroute
-$ nmap --traceroute 192.168.0.1
-$ traceroute -T 192.168.0.1      # option -T pour faire du TCP plutôt que de l'UDP
-</code>
-__Nota Bene__ : Si le nmap est trop lent dans les UML, vous pouvez le rendre plus agressif avec les options "-n -T5".
-==== TP4 (NAT) ====
-__Préliminaires__ :
-Pour afficher la table NAT :
-  $ iptables -t nat -L
-Pour remettre la table à zéro :
-  $ iptables -t nat -F
-L'écriture des règles NAT n'est pas symétrique ! On translate les adresses privés en publique en sortant du rx privé. Par ailleurs la configuration du NAT s'effectue avec 'iptables' sur la passerelle uniquement !
-__NAT Statique__ : association 1 @priv et 1 @pub (action SNAT / DNAT)
-a) Paquet Entrant dans le Réseau Privé
-On modifie l'adresse de destination (DNAT) avant le routage (PREROUTING).
-  $ iptables -t nat -A PREROUTING -d @pub -i ethin -j DNAT --to-destination @priv
-La translation inverse est implicite lors de la réponse.
-b) Paquet Sortant vers le Réseau extérieur
-On modifie l'adresse source (SNAT) après le routage (POSTROUTING).
-  $ iptables -t nat -A POSTROUTING -s @priv -o ethout -j SNAT --to-source @pub
-La translation inverse est implicite lors de la réponse.
-__NAT Dynamique__ : association N @priv et 1 @pub (action MASQUERADE) avec @priv une adresse de réseau et mask un masque en nb de bits
-  $ iptables -t nat -A POSTROUTING -s @priv/mask -j MASQUERADE
-__En résumé__ :
-  * Connexion initié depuis l'intérieur => POSTROUTING / SNAT ou MASQUERADE
-  * Connexion initié depuis l'extérieur => PREROUTING / DNAT (MASQUERADE impossible)
-__Exemple__
-Considérons les réseaux privés 192.168.0.0/24 et 192.168.1.0/24 connectés à la passerelle immortal d'adresse publique 140.77.13.2 (eth1). Pour mettre en place du NAT dynamique pour ces réseaux privés, je recommande :
-  immortal$ iptables -t nat -A POSTROUTING -s 192.168.0.0/23 -o eth1 -j MASQUERADE
-__Port Forwarding__
-On veut mettre en place du port forwarding entre la passerelle //immortal// (147.210.20.1) port 2222 et le port 22 (SSH) de //syl// dans le réseau privé (192.168.0.3).
-  immortal$ iptables -t nat -A PREROUTING -d 147.210.20.1 -p tcp --dport 2222 -j DNAT --to 192.168.0.3:22
-  atg$ ssh toto@147.210.20.1            # SSH vers immortal
-  atg$ ssh -p 2222 toto@147.210.20.1    # SSH vers syl
-==== TP5 (Firewall)====
-== Memento ==
-Voici quelques notes concernant l'utilisation d'iptables pour configurer un firewall. La configuration du firewall se base sur la table "filter" et est subdivisée en 3 chaînes (notée <CHAIN>) :
-  * INPUT : tout ce qui rentre dans la machine ;
-  * OUTPUT : tout ce qui sort dans la machine ;
-  * FORWARD : tout ce qui traverse la machine (i.e. lors du routage).
-Pour afficher les règles de la table filter :
-  $ iptables -t filter -L -v
-Pour effacer toutes les règles ajoutées :
-  $ iptables -t filter -F
-Pour chaque règle que l'on ajoute, trois actions sont possibles (notée <ACTION>) :
-  * ACCEPT : on accepte ;
-  * REJECT : on rejette poliment (réponse d'erreur envoyé à l'émetteur) ;
-  * DROP : on jette à la poubelle (pas de réponse d'erreur).
-Pour modifier la politique par défaut du firewall :
-  $ iptables -t filter -P <CHAIN> <ACTION>
-Pour ajouter une nouvelle règle à une chaîne du firewall (attention à l'ordre des règles) :
-  $ iptables -t filter -A <CHAIN> <SRC> <DST> <...> -j <ACTION>
-  * avec <SRC> des indications sur la provenance des paquets IP, comme par exemple "-i eth0" ou "-s 192.168.0.0/24" ou encore "-s 0/0" ;
-  * avec <DST> des indications sur la destination des paquets IP, comme par exemple : "-o eth1" ou "-d 147.210.0.0/24" ;
-  * avec <...> des infos complémentaires sur par exemple la nature du protocole "-p icmp" ou "-p tcp", avec éventuellement des precisions spécifiques à ces protocoles ("--dport 80" pour TCP) ou encore sur l'état "-m state --state NEW", ...
-Pour plus d'info, consulter le manuel : man iptables.
-==Accepter le traffic partant du réseau interne vers des serveurs web ou SSH==
-Soit 192.168.1.0/24 notre réseau interne. On configure le firewall sur //immortal// notre passerelle.
-<code bash>
-$ iptables -F
-$ iptables -P FORWARD DROP
-$ iptables -P INPUT DROP
-$ iptables -P OUTPUT DROP
-# traffic sortant
-$ iptables -A FORWARD -s 192.168.1.0/24 -m multiport -p tcp --dport 22,80 -j ACCEPT
-# traffic retour
-$ iptables -A FORWARD -d 192.168.1.0/24 -m multiport -p tcp --sport 22,80 -m state --state ESTABLISHED -j ACCEPT
-</code>
-== Accepter un ping toutes les 10s à destination de nile ==
-Soit //nile// la machine 192.168.0.4. On configure le firewall sur //immortal// notre passerelle.
-<code bash>
-$ iptables -F
-$ iptables -P FORWARD DROP
-$ iptables -A FORWARD -d 192.168.0.4 -p icmp -m limit --limit 6/mn --limit-burst 1 -j ACCEPT
-$ iptables -A FORWARD -s 192.168.0.4 -p icmp -m state --state ESTABLISHED -j ACCEPT
-</code>
-Pour faire un test depuis une machine extérieure, on envoie un ping à //nile// toutes les 5 secondes...
-  $ ping -i 5 192.168.0.4
-==== TP6 (NIS & NFS) ====
-__Attention__ : Vérifier que le service //rpcbind// est bien démarré, sinon il faut penser à le lancer.
-  $/etc/init.d/rpcbind start
-== Configuration du serveur NIS==
-On choisit un nom de domaine //mydomain// :
-  root@immortal:~ #echo mydomain > /etc/defaultdomain
-On positionne également le nom de domaine courant à //mydomain//
-  root@immortal:~ #domainname mydomain
-On peut vérifier que le domainne courant est bien positionné en tapant la commande //domainname//.
-On configure //immortal// comme serveur (maître), en indiquant dans le fichier /etc/default/nis
-  ...
-  # Are we a NIS server and if so what kind (values: false, slave, master)?
-  NISSERVER=master
-  ...
-Puis on construit la base de données, en exportant les comptes courants (définis dans /etc/passwd) comme des comptes NIS.
-  root@immortal:~ #cd /var/yp/ ; make
-Un message d'erreur indique que le serveur ne NIS n'est pas encore lançé !
-On démarre donc le serveur NIS :
-  root@immortal:~ #/etc/init.d/nis restart
-  Starting NIS services: ypserv yppasswdd ypxfrd ypbind.
-OK c'est parti... sinon on vérifie les logs (/var/log/syslog).
-On regénère proprement la basse de données NIS.
-  root@immortal:~ # cd /var/yp/
-  root@immortal:~ # rm -rf mydomain               # raz de la database
-  root@immortal:~ # make                          # on génére à nouveau la database
-    Updating passwd.byname...
-    Updating passwd.byuid...
-    Updating group.byname...
-    Updating group.bygid...
-    Updating hosts.byname...
-    Updating hosts.byaddr...
-    Updating rpc.byname...
-    Updating rpc.bynumber...
-    Updating services.byname...
-    Updating services.byservicename...
-    Updating netid.byname...
-    Updating protocols.bynumber...
-    Updating protocols.byname...
-    Updating netgroup...
-    Updating netgroup.byhost...
-    Updating netgroup.byuser...
-    Updating shadow.byname...
-Tous les utilisateurs locaux sur le serveur NIS avec un UID > 1000 sont exportés dans la database.
-En lançant la commande  //rpcinfo  -p// on voit apparaître les différents services RPC utiles à NIS : //ypserv, yppasswdd, ypbind, fypxfrd//.
-==Configuration du client==
-On vérifie que le fichier /etc/default/nis est bien configuré pour être client NIS. Puis on configure le nom de domaine NIS et on démarre le service NIS (côté client).
-  root@grave:~ #echo "mydomain" > /etc/defaultdomain
-  root@grave:~ #domainname mydomain
-  root@grave:~ #/etc/init.d/nis restart
-    Starting NIS services: ypbind.
-Pour vérifier que l'on trouve bien le serveur NIS depuis le client :
-  root@grave:~ #ypwhich
-.168.0.1
-Pour afficher la liste des comptes utilisateur NIS :
-  root@grave:~ #ypcat passwd
-Il faut ensuite éditer le fichier /etc/nsswitch.conf qui sert à expliquer à l'OS quelle stratégie utiliser pour l'autenthification (unix files, nis, ldap, compat, ...)
-  passwd:         files nis        # compat
-  group:          files nis        # compat
-  shadow:         files nis        # compat
-  ...
-Attention, il faut recharger le fichier //nsswitch.conf// il faut faire :
-  /etc/init.d/nscd restart
-Avec la séquence //files nis//, on vérifie d'abord les comptes locaux dans /etc/, puis après on cherche sur le serveur NIS.
-== Ajouter des nouveaux utilisateurs NIS sur le serveur ==
-On commence par désactiver kerberos & ldap
-  root@immortal:~ #pam-auth-update
-Puis on ajoute les utilisateurs Unix //titi// et //tutu// :
-  root@immortal:~ #adduser titi
-    password titi
-  root@immortal:~ #adduser tutu
-    pasword tutu
-On met à jour la base de données NIS :
-  root@immortal:cd /var/yp ; make
-   Updating passwd.byname...
-   Updating passwd.byuid...
-   Updating netid.byname...
-   Updating shadow.byname...
-Maj de la base, pas besoin de restarter le serveur NIS...
-  root@grave:~ #ypcat passwd
-    tutu:x:1002:1002:,,,:/home/tutu:/bin/bash
-    titi:x:1001:1001:,,,:/home/titi:/bin/bash
-    toto:x:1000:1000:,,,:/home/toto:/bin/bash
-Pour tester NIS on passe par un tiers utilisateur plutôt que par root (root ne vérfie pas le password) !
-  root@grave:~ #su toto
-  toto@grave:/root$ su titi
-  Mot de passe : xxxx
-  titi@grave:/root$
-==Configuration de NFS==
-Il ne faut pas oublier de configurer le serveur NFS comme un client NIS ! Pour mettre à jour le cache des utilisateurs NIS sur un client, il est utile de relancer le démon NSCD (NameService Cache Daemon) /etc/init.d/nscd restart
-__Côté serveur NFS__
-On configure le serveur NFS sur syl ; grave sert de client.
-Sur le serveur, le répertoire NFS sera /pub.
-  root@syl$ mkdir /pub
-On indique cela /etc/exports de la façon suivante :
-  /pub (rw,no_root_squash)
-Autres Exemples (man exports) :
-  /pub host1(ro) host2(rw,no_root_squash)
-  /pub @netgroup(rw)
-  /pub (ro)
-Par defaut, //root_squash// : l'utilisateur root (uid=0,gid=0) est mappé sur //anonymous// avec des droits restreints ! Autres options : no_root_squash, all_squash
-On démarre le common et le serveur NFS (nécessaire après chaque modif de /etc/exports) :
-  root@grave$ /etc/init.d/nfs-common restart
-  root@grave$ /etc/init.d/nfs-kernel-server restart
-__Côté client NFS__
-Sur grave, déjà configuré comme un client NIS.
-On démarre le //common// NFS (après chaque modif de /etc/exports) :
-  root@grave$ /etc/init.d/nfs-common restart
-On crée le montage NFS dans /mnt/pub :
-  root@grave$ mkdir /mnt/pub
-  root@grave$ chmod 777 /mnt/pub
-  root@grave$ mount -t nfs -o nfsvers=3 192.168.0.1:/pub /mnt/pub         # @serveur_nfs = 192.168.0.1
-On crée des fichiers vides (commande //touch//) sur la machine client en tant que //tutu// et //titi//.
-  root@grave:/mnt/pub$ su tutu
-  tutu@grave:/mnt/pub$ touch tutu
-  root@grave:/mnt/pub$ su titi
-  titi@grave:/mnt/pub$ touch titi
-On vérifie les droits...
-  root@grave:/mnt/pub$ ls -l
-    -rw-r--r-- 1 titi titi 0 2008-03-11 13:28 titi
-    -rw-r--r-- 1 tutu tutu 0 2008-03-11 13:28 tutu
-On peut également configurer le point de montage de manière permanente dans /etc/fstab
-  root@grave$ jmacs /etc/fstab
-  <file system>      <mount point>   <type>  <options>  <dump> <pass>
-.168.0.3:/pub   /mnt/test        nfs    rw         0       0
-==En conclusion==
-Donc on a :
-  * immortal : serveur NIS (compte NIS tutu et titi)
-  * syl : serveur NFS (export de /pub) & client NIS
-  * grave : client NIS & NFS (montage dans /mnt/pub)
-Pour terminer de tout bien configurer, il faut créer sur le serveur NFS les repertoires /pub/tutu et /pub/titi appartenant respectivement aux utilsateurs tutu et titi, avec les bons droits d'accès Unix. Il faut ensuite mettre à jour le /etc/passwd du serveur NIS pour indiquer comme //home directory// les répertoires /mnt/pub/tutu et /mnt/pub/titi.  Puis on met à jour la base NIS. Et on teste sur le client que l'on se connecte bien dans le //home directory// monté par NFS. Pensez à recharger le cache NSCD côté client NIS avant de faire des tests ;-)
-==== TP7 LDAP ====
-NIS c'est un peu démodé... Aujourd'hui, on préfère utiliser LDAP.
-== 1) Configuration du serveur LDAP==
-On configure le serveur LDAP sur la machine //immortal//. Les autres machines servent de client.
-<code>
-  immortal$ adduser tutu
-  immortal$ adduser titi
-</code>
-Création d'un password pour l'admin LDAP:
-<code>
-  immortal$ slappasswd
-    New password: admin
-    Re-enter new password: admin
-    {SSHA}XSd0QXLAiNz734f/8QGpaujkMdK5BxWp
-</code>
-Editer le fichier /etc/ldap/sldap.conf (attention, pas d'espace en début de ligne) :
-<code>
-   # nom du domaine LDAP
-   suffix          "dc=mydomain,dc=fr"
-   # nom de l'admin
-   rootdn          "cn=admin,dc=mydomain,dc=fr"
-   # ajout d'un mot de passe admin
-   rootpw	   "{SSHA}XSd0QXLAiNz734f/8QGpaujkMdK5BxWp"
-</code>
-__Attention__ : Ne pas oublier de corriger le nom de domaine pour les ACLs en fin de fichier ! En gros, il faut remplacer tous les @XXXXXXXXX@ !
-__Nota Bene__ : dc = domain component
-Dans le fichier /etc/default/slapd, modifiez :
-<code>
-  SLAPD_CONF="/etc/ldap/slapd.conf"
-</code>
-Démarrage du serveur LDAP :
-<code>
-  immortal$ /etc/init.d/slapd start
-</code>
-On vérifie que le démon a démarré !
-<code>
-  immortal$ ps aux |grep slapd
-</code>
-==2) Ajout des comptes dans le serveur LDAP==
-On va utiliser un script pour peupler automatiquement la base LDAP avec les comptes des utilisateurs (et d'autres trucs). Editer le fichier /etc/migrationtools/migrate_common.ph, et mettre à jour votre nom de domaine :
-<code>
-# Default DNS domain
-$DEFAULT_MAIL_DOMAIN = "mydomain.fr";
-# Default base
-$DEFAULT_BASE = "dc=mydomain,dc=fr";
-</code>
-Ensuite, il faut lancer le script :
-<code>
-  immortal$ cd /usr/share/migrationtools      # Important : il faut dans ce répertoire...
-  immortal$./migrate_all_online.sh            # ... pour lancer le script !
-Enter the X.500 naming context you wish to import into: [dc=mydomain,dc=fr]
-Enter the hostname of your LDAP server [ldap]: localhost
-Enter the manager DN: [cn=admin,dc=mydomain,dc=fr]:
-Enter the credentials to bind with:            <-- mot de passe de l'admin !!!
-Do you wish to generate a DUAConfigProfile [yes|no]? no
-Importing into dc=mydomain,dc=fr...
-Creating naming context entries...
-Migrating groups...
-Migrating hosts...
-Migrating networks...
-Migrating users...
-Migrating netgroups...
-Migrating netgroups (by user)...
-Migrating netgroups (by host)...
-Importing into LDAP...
-adding new entry "dc=mydomain,dc=fr"
-...
-adding new entry "cn=root,ou=Group,dc=mydomain,dc=fr"
-...
-adding new entry "cn=toto,ou=Group,dc=mydomain,dc=fr"
-adding new entry "cn=tutu,ou=Group,dc=mydomain,dc=fr"
-adding new entry "cn=titi,ou=Group,dc=mydomain,dc=fr"
-...
-adding new entry "cn=localhost,ou=Hosts,dc=mydomain,dc=fr"
-adding new entry "cn=cinder.localdomain,ou=Hosts,dc=mydomain,dc=fr"
-...
-adding new entry "uid=toto,ou=People,dc=mydomain,dc=fr"
-adding new entry "uid=tutu,ou=People,dc=mydomain,dc=fr"
-adding new entry "uid=titi,ou=People,dc=mydomain,dc=fr"
-</code>
-==En cas d'erreur==
-Bon, si ça ne marche pas, on fait le ménage :
-  $/etc/init.d/slapd stop
-  $ rm -rf /var/lib/ldap/*
-On vérifie ses configs et on recommence !!!
-  $/etc/init.d/slapd start
-==Test client==
-On effectue une recherche sur toutes les entrées "objectclass=*"
-  immortal$ ldapsearch -x -b "dc=mydomain,dc=fr" -D "cn=admin,dc=mydomain,dc=fr" "(uid=*)" -W
-ou plus simplement si tout le monde peut consulter le serveur LDAP (cf. ACL) :
-  immortal$ ldapsearch -x "(uid=*)"
-Comparer le nombre de répondes avec /etc/passwd sur le serveur :
-<code>
-  immortal$ wc -l /etc/passwd
-</code>
-L'ajout manuel d'une entrée se fait via un fichier LDIF (cf. manuel) :
-  immortal$ grep tutu /etc/passwd > tutu
-  immortal$ migrate-passwd.pl tutu > tutu.ldif
-  immortal$ ldapadd -x -D "cn=admin,dc=mydomain,dc=fr" -W -f tutu.ldif
-== 3) Configuration d'un client LDAP==
-__Nota Bene__ : Il n'y a pas de démon côté client!
-Editer le fichier /etc/ldap/ldap.conf sur la machine cliente :
-<code>
-  BASE    dc=mydomain,dc=fr
-  URI     ldap://192.168.0.1   <--- IP du serveur LDAP !
-</code>
-Un petit test sur le client (pas besoin de mettre l'option -b)
-  $ ldapsearch -x -D "cn=admin,dc=mydomain,dc=fr" "(objectclass=account)" -W
-== 4) Authentification via LDAP ==
-Dans le fichier /etc/nsswitch.conf, ajouter ldap
-<code>
-  passwd:         files ldap
-  group:          files ldap
-  shadow:         files ldap
-</code>
-__Attention__ : Ne pas oublier //files//, sinon mieux vaut que //ldap// fonctionne du premier coup !!!
-  $ /etc/init.d/nscd restart
-A partir d'ici, les comptes LDAP sont visibles, mais l'authentification ne marche pas encore, car il faut encore configurer PAM, pour y authoriser l'authentification via LDAP.
-On lance la commande suivante et on sélectionne Unix + LDAP.
-  $ pam-auth-update
-Ensuite :
-  $ dpkg-reconfigure libpam-ldap
-  $ dpkg-reconfigure libnss-ldapd
-Attention, il faut saisir ldap://192.168.0.1  (ET NON ldapi !)
-Pour finir :
-  $ dpkg-reconfigure nslcd
-A vous de jouer... on peut ajouter le serveur NFS !
-==== TP8 DNS & DHCP ====
-== Config Serveur DNS ==
-domain: metal.fr
-server: immortal (192.168.0.2)
-Dans /etc/bind/named.conf.local :
-<code>
-zone "metal.fr" {
-        type master;
-        file "/etc/bind/db.metal";
-};
-zone "0.168.192.in-addr.arpa" {
-        type master;
-        file "/etc/bind/db.0.168.192";
-};
-</code>
-Dans /etc/bind/db.metal :
-<code>
-; $ORIGIN metal.fr
-$TTL	86400
-@	IN	SOA	dns1.metal.fr. mailer.metal.fr. (
-		; Serial
-		; Refresh
-		; Retry
-			2419200		; Expire
-)	; Negative Cache TTL
-;
-@	IN	NS	immortal
-@	IN	MX	10	nile
-immortal	IN	A	192.168.0.2
-syl		IN	A	192.168.0.1
-nile		IN	A	192.168.0.3
-; alias
-mailer		IN	CNAME	nile
-dns1		IN	CNAME	immortal
-</code>
-__Nota Bene__ : NS = DNS Server, IN = Internet (optionel), mailer.metal.fr => mailer@metal.fr (@email du DNS admin)
-Dans /etc/bind/db.0.168.192 (reverse) :
-<code>
-; $ORIGIN 0.168.192.in-addr.arpa
-$TTL	86400
-@	IN	SOA	dns1.metal.fr. mailer.metal.fr. (
-		; Serial
-		; Refresh
-		; Retry
-			2419200		; Expire
-)	; Negative Cache TTL
-;
-@	IN	NS	dns1.metal.fr.
-; reverse
-	IN	PTR	immortal.metal.fr.
-	IN	PTR	syl.metal.fr.
-	IN	PTR	nile.metal.fr.
-</code>
-Vérif Config Serveur :
-<code>
-  $ named-checkzone 0.168.192.in-addr.arpa db.0.168.192
-  $ named-checkzone metal.fr db.metal
-  $ named-checkconf
-</code>
-Démarrage du serveur :
-  $ /etc/init.d/bind9 restart
-Les logs :
-  $ tail /var/log/syslog
-==Config Client DNS==
-Dans /etc/resolv.conf :
-<code>
-search metal.fr
-nameserver 192.168.0.2
-</code>
-Dans /etc/nsswitch.conf :
-<code>
-...
-hosts:          files dns
-...
-</code>
-Ne pas oublier de redémarrer le daemon //nscd//.
-Test Client, sur syl par exemple :
-<code>
-  $ nslookup nile
-  Server:		192.168.0.2
-  Address:	192.168.0.2#53
-  Name:	nile.metal.fr
-  Address: 192.168.0.3
-  $ ping nile
-  PING nile.metal.fr (192.168.0.3) 56(84) bytes of data.
-bytes from nile.metal.fr (192.168.0.3): icmp_seq=1 ttl=64 time=12.8 ms
-</code>
-== Config du serveur DHCP ==
-//Serveur DHCP su syl.//
-__Configuration sans DNS__
-Dans /etc/dhcp/dhcpd.conf:
-<code>
-  default-lease-time 600;
-  max-lease-time 7200;
-  subnet 192.168.0.0 netmask 255.255.255.0 {
-    range 192.168.0.10 192.168.0.20;
-    option broadcast-address 192.168.0.255;
-  }
-</code>
-On démarre le serveur DHCP :
-   $/etc/init.d/isc-dhcp-server start
-__Configuration avec DNS__
-On suppose le serveur DNS bien configuré sur immortal...
-Dans /etc/dhcp/dhcpd.conf (syl), ajouter à la fin :
-<code>
-subnet 192.168.0.0 netmask 255.255.255.0 {
-  range 192.168.0.10 192.168.0.30;               # Range of IP addresses to be issued to DHCP clients
-  option domain-name "metal.fr";		 # Domain name
-  option domain-name-servers 192.168.0.2;        # Default DNS to be used by DHCP clients
-  # option routers 192.168.0.254;		 # Default gateway to be used by DHCP clients
-  option subnet-mask 255.255.255.0;		 # Default subnet mask to be used by DHCP clients
-  option broadcast-address 192.168.0.255;      	 # Default broadcast address to be used by DHCP clients
-  host nile {
-    hardware ethernet A2:00:00:00:03:00;
-    fixed-address 192.168.0.9;
-  }
-}
-</code>
-On redémarre le serveur DHCP.
-== Configuration du Client DHCP==
-Dans /etc/network/interfaces (nile) :
-<code>
-  auto eth0
-  iface eth0 inet dhcp
-</code>
-Puis on démarre le client...
-  $/etc/init.d/networking restart
-Ou encore :
-<code>
-  root@nile:~ #dhclient -v
-  Listening on LPF/eth0/a2:00:00:00:03:00
-  Sending on   LPF/eth0/a2:00:00:00:03:00
-  Sending on   Socket/fallback
-  DHCPDISCOVER on eth0 to 255.255.255.255 port 67 interval 4
-  DHCPOFFER from 192.168.0.1
-  DHCPREQUEST on eth0 to 255.255.255.255 port 67
-  DHCPACK from 192.168.0.1
-  bound to 192.168.0.10 -- renewal in 265 seconds.
-</code>
-On peut vérifier les entrées ajoutées dynamiquement sur le serveur DHCP dans le fichier /var/lib/dhcp/dhcpd.leases
-==Configuration avançée du serveur DHCP==
-On souhaite maintenant faire en sorte que le serveur DHCP collabore avec le serveur DNS pour mettre à jour automatiquement la liste desnouvelles machines reconnues par DNS.
-On utilise le secret définie dans /etc/bind/rndc.key
-On modifie la config DHCP du serveur dans /etc/dhcp/dhcpd.conf :
-<code>
-  ddns-update-style interim;
-  ddns-updates on;
-  deny client-updates;
-  ddns-domainname "metal.fr.";
-  ddns-rev-domainname "0.168.192.in-addr.arpa.";
-  authoritative;
-  key "rndc-key" {
-    algorithm hmac-md5;
-    secret "nnuTF/RJEhvmKhttRzIv8w==";
-  }
-  zone metal.fr. {
-    primary 192.168.0.2;
-    key rndc-key;
-  }
-  zone 0.168.192.in-addr.arpa. {
-    primary 192.168.0.2;
-    key rndc-key;
-  }
-  subnet 192.168.0.0 netmask 255.255.255.0 {
-    range 192.168.0.10 192.168.0.30;               # Range of IP addresses to be issued to DHCP clients
-    option domain-name "metal.fr";		   # Domain name
-    option domain-name-servers 192.168.0.2;        # Default DNS to be used by DHCP clients
-    option subnet-mask 255.255.255.0;		   # Default subnet mask to be used by DHCP clients
-    option broadcast-address 192.168.0.255;        # Default broadcast address to be used by DHCP clients
-  }
-</code>
-Puis on modifie la config su serveur DNS dans /etc/bind/named.conf.local :
-<code>
-key "rndc-key" {
- algorithm hmac-md5;
- secret "nnuTF/RJEhvmKhttRzIv8w==";
-};
-zone "metal.fr" {
-        type master;
-        file "/etc/bind/db.metal";
-        allow-update {key "rndc-key"; };
-};
-zone "0.168.192.in-addr.arpa" {
-        type master;
-        file "/etc/bind/db.0.168.192";
-        allow-update {key "rndc-key"; };
-};
-</code>
-Ne pas oublier chmod g+wx /etc/bind (pour le group "bind").
-Finalement, côté client DHCP (nile), dans /etc/dhcp/dhclient.conf :
-<code>
-send host-name "ninile";
-</code>
-Puis :
-  $ dhclient -v
-==== TP9 WINDOWS ====
-On considère le réseau suivant : une machine Windows 7 (172.16.1.1/16) connectée à une machine Linux Immortal (eth1, 172.16.0.1/16). Immortal est ensuite connectée à deux autres machines Linux Syl (via eth0) et Nile (via eth2).
-==Configuration des machines Linux==
-<code bash>
-immortal$ ifconfig eth1 172.16.0.1/16                 # connexion à win7
-immortal$ echo 1 > /proc/sys/net/ipv4/ip_forward      # mode routeur
-immortal$ ifconfig eth0 192.168.0.1/24                # connexion à syl
-immortal$ ifconfig eth2 192.168.1.1/24                # connexion à nile
-syl$ ifconfig eth0 192.168.0.2/24
-syl$ route add default gw 192.168.0.1                    # route par défaut vers la machine windows
-nile$ ifconfig eth0 192.168.1.2/24
-nile$ route add default gw 192.168.1.1                   # route par défaut vers la machine windows
-</code>
-==Configuration de la machine Windows==
-Configurez l'interface réseaux Windows avec l'IP 172.16.1.1/16 en utilisant l'interface graphique du Control Panel, puis Network/Property/../IPv4/Property. A priori, c'est déjà fait.
-En ligne de commande, il faut lancer le //Command Prompt// dans le menu Windows. Faire un clic droit, //Run as Administrator// pour avoit un terminal avec les droits "root".
-La machine Windows et déjà configuré : on vérifie :
-  win$ ipconfig.exe /all
-  win$ route.exe print
-Si tout est OK, on doit pouvoir faire un ping vers notre UML
-  win$ ping.exe 172.16.0.1
-Lancer MMC (Microsoft Management Console), qui va permettre de gérer toute la config...
-  win$ mmc.exe
-/* Il faut commencer par ajouter via le menu "File/Add Snap-In". L'option Windows Firewall with Advanced Security... qui permet également de configurer IPSEC */
-Attention, il y a plusieurs "profile" pour les règles du firewall (public, domain, private, all). On vérifiera que la firewall est bien ON avec le profile "public" ACTIVE.
-On peut commencer par inactiver le firewall... puis par faire des tests ICMP vers toutes les machines Linux, en ajoutant par exemple 172.16.0.1 comme default gateway dans Windows (interface graphique).
-Si on active le firewall, le ping de windows vers linux fonctionne (pas de firewall sur immortal), mais en revanche l'inverse ne marche pas.
-__Nota Bene__: Windows autorise le Established de base !
-Il faut rajouter une petite règle ICMP qui va bien via la MMC, pour autoriser le ping. Add "New Inbound Rules" / Custom Rule / et après c'est facile... On peut maintenant, vérifier que le ping fonctionne de manière
-symétrique.
-Pour définir une route par défaut, il faut utiliser 0.0.0.0 comme réseau cible et 255.255.255.255 comme masque !
-  # route par défaut (gateway immortal)
-  win$ route add 0.0.0.0 mask 0.0.0.0 172.16.0.1
-On va virer la default gateway, pour rajouter à la main... des routes spécifiques vers les réseaux de syl et opeth...
-  # vers opeth
-  win$ route add 192.168.0.0 mask 255.255.255.0 172.16.0.1 [if 16]
-  # vers syl
-  win$ route add 192.168.1.0 mask 255.255.255.0 172.16.0.1 [if 16]
-Le numéro d'interface [if x] se trouve avec "route.exe print"
-Un peu plus d'aide...
-  win$ route.exe /?
-Un petit test avec Netcat. On lance le programme en mode serveur //nc.exe//, dans c:\Users\toto\Desktop\ (commandes //cd// et //dir// pour naviguer)
-  win$ nc.exe -l -p 5555
-Windows vous demande si vous souhaitez ajouter une exception dans le firewall pour autoriser les connexions vers le programme nc.exe (all IPs, all ports, TCP & UDP). Si on dit Allow, bah ça marche tout seul !
-  syl$ telnet 172.16.1.1 5555     # connexion au serveur netcat de la machine windows !
-Pour sortir de Telne, faire ctrl-], puis taper telnet> quit  ;-)
-__Nota Bene__ : Firewall Windows, regarde en premier les règles "block", ensuite "allow" et ensuite "default". IPsec se place au dessus.