L’installation peut soit ce faire par compilation soit par téléchargement direct d’un binaire universel (fonctionnant donc à la fois sur architecture PowerPC et Intel).

La dernière version date de novembre 2007 et est numérotée 9.0-RC3.

C’est beau, c’est stable, c’est libre…

Rappel: le protocole DHCP permet la configuration automatique des paramètres IP des machines d’un réseau (plus de littérature sur le Wiki).

Introduction

ISC DHCP est un projet open-source disponible dans une suite qui comprend les éléments suivants:

• le fameux serveur DHCPd
• le client DHCPclient
• un serveur de relais DHCPrelay

Cette suite est disponible sur la plupart des OS: Linux, BSD, Mac OS X et Windows.

La dernière version stable à la date de l’éecriture de ce billet est la 3.0.6

Installation du serveur DHCPd

Sous FreeBSD la procédure est la suivante:

# pkg_add -r isc-dhcp3-server

Pour les puristes, il est également de compiler le serveur à partir des sources.

Quelques trucs utiles à savoir avant la configuration

DHCP est un protocole servant à distribuer des configurations réseaux (c’est à dire adresse IP, masque, routes, serveurs DNS…) sur un réseau local. Il faut donc que le serveur et les clients se trouvent sur un même réseau de niveau 2. En clair, il ne doit pas y avoir de routeur IP entre le serveur et les clients. Si vous ne pouvez pas faire autrement, le serveur relais pourra vous être utile…

Si vous avez un Firewall entre votre serveur et vos clients, il faut veillez à ajouter les règles suivantes:

Autoriser les paquets UDP/67 (source UDP/68) entre l’adresse 0.0.0.0 et l’adresse 255.255.255.255

Autoriser les paquets UDP/68 (source UDP/67) entre le serveur et les clients

C’est à dire autoriser vos clients qui n’ont pas encore d’adresse IP (0.0.0.0) à envoyer sur le réseau une requête DHCP (UDP/67) vers toutes les machines du réseau (255.255.255.255) afin de chercher le serveur DHCP. Le serveur DHCP répond (UDP/68) en offrant un bail DHCP (c’est à dire une configuration IP valable un certain temps).

Sous FreeBSD, la règle IPFW correspondante est:

# ipfw add allow udp from 0.0.0.0 68 to 255.255.255.255 67 keep-state

# ipfw add allow udp from @SERVEUR 67 to any 68 keep-state

Configuration du serveur DHCP

Toute la configuration est centralisée dans le fichier dhcpd.conf. Nous allons donc commencer par archiver la configuration par défaut.

# mv /usr/local/etc/dhcpd.conf.sample /usr/local/etc/dhcpd.conf

Puis éditer notre fichier dhcpd.conf:

# vi /usr/local/etc/dhcpd.conf

# C’est bien le serveur DHCP principal

authoritative;

# Nom de domaine de votre réseau

option domain-name “monboreseau.com”;

# Adresses des serveurs DNS

option domain-name-servers ns1.monboreseau.com, ns2.monboreseau.com;

# Définition de la durée du bail

default-lease-time 600;

max-lease-time 7200;

# On logue les messages dans le syslog

log-facility local7;

# Définition des plages d’adresses dynamiques du LAN

subnet 192.168.1.0 netmask 255.255.255.0 {

range 192.168.1.100 192.168.1.200 ;

option routers 192.168.1.1 ;

option broadcast-address 192.168.1.255 ;

}

# Définition des machines statiques (les entrées doivent exister dans le serveur DNS)

# Attention, elles doivent être en dehors du range dynamique définie ci-dessus.

host mamachine {

hardware ethernet 00:11:09:1A:-:- ;

fixed-address mamachine.alcasat.net ;

}

Les opérations de base sur votre serveur DHCP

Démarrage du serveur (sous FreeBSD):

# /usr/local/etc/rc.d/isc-dhcpd start

Arrêter le serveur DHCP (sous FreeBSD):

# /usr/local/etc/rc.d/isc-dhcpd stop

Pour connaître la liste des baux (leases) en cours:

# cat /var/db/dhcpd.leases

Exemple:

lease 192.168.1.112 {

starts 2 2008/05/13 10:22:43;

ends 2 2008/05/13 10:32:43;

binding state active;

next binding state free;

hardware ethernet 00:08:02:f4:-:-;

uid “\001\000\010\002\364o\310″;

client-hostname “port2″;

}

Et la redondance ?

Si vous souhaitez avoir deux serveurs DHCP en redondance sur votre réseau, vous pouvez suivre cette procédure.

Si vous êtes votre propre héberger, le service DNS est une des premières brique à mettre en place sur votre réseau. Nous allons dans ce billet décrire l’installation d’une architecture DNS avec deux serveurs (un primaire et un secondaire).

Pour illustrer ce billet nous allons prendre l’exemple du réseau suivant:

• Adressage privée en 192.168.1.0/24
• Adressage public en 80.80.80.0/24
• Adresse du serveur primaire: 80.80.80.1 avec comme nom ns1
• Adresse du serveur secondaire: 192.168.1.1 avec comme nom ns2
• Nom de votre domaine: monboreseau.com

Installation des serveurs DNS

Nous allons nous baser sur l’implémentation ISC Bind pour nos serveurs DNS. Le processus à lancer s’appelle named, il doit logiquement être présent sur votre système GNU/Linux ou BSD.

Pour vérifier que named est bien installé et que vous avez une version à jour:

# named -v

BIND 9.4.

Le site officiel pour vérifier la version est ici.

Configuration du serveur primaire

C’est le serveur maître qui doit être accessible depuis Internet sur le port TCP/53.

La configuration est centralisé dans le répertoire /etc/namedb.

Nous commençons par éditer le fichier named.conf:

# vi /etc/namedb/named.conf

options {

directory “/etc/namedb”;

query-source address * port 53;

};

logging {

channel lames {

file “/var/log/named.run”;

severity debug;

};

category default { lames; };

};

zone “.” {

type hint;

file “named.root”;

};

zone “0.0.127.IN-ADDR.ARPA” {

type master;

file “localhost.rev”;

};

// Zone MONBORESEAU.COM

zone “monboreseau.com” {

type master ;

file “master/monboreseau.com” ;

} ;

// Zone 192.168.1.0

zone “0.1.168.192.in-addr.arpa” {

type master ;

file “master/0.1.168.192.in-addr.arpa” ;

} ;

// Zone 80.80.80.0

zone “0.80.80.80.in-addr.arpa” {

type master ;

file “master/0.80.80.80.in-addr.arpa” ;

} ;

Il faut ensuite remplir les fichiers des zones avec vos machines. Nous commençons par la zone primaire (qui donne l’adresse IP en fonction du nom):

# vi /etc/namedb/master/monboreseau.com

$ORIGIN .

$TTL 86400 ; 1 day

alcasat.net IN SOA ns1.monboresau.com. support.monboreseau.com. (

2008042902 ; serial

21600 ; refresh (6 hours)

3600 ; retry (1 hour)

604800 ; expire (1 week)

86400 ; minimum (1 day)

)

NS ns1.monboreseau.com.

NS ns2.monboreseau.com.

MX 10 mail.monboreseau.com.

$ORIGIN monbeaureseau.com.

ns1 A 80.80.80.1

machine1 A 80.80.80.2

ns2 A 192.168.1.1

machine2 A 192.168.1.2

…

Puis par les zones reverses (qui donne le nom par rapport à l’adresse IP):

# vi /etc/namedb/master/0.80.80.80.in-addr.arpa

$ttl 86400

@ IN SOA ns1.monboreseau.com. support.monboreseau.com. (

2008040101 ;

21600 ;

3600 ;

604800 ;

86400 ) ;

@ IN NS ns1.monboreseau.com.

@ IN NS ns2.monboreseau.com.

1 IN PTR ns1.monboreseau.com.

2 IN PTR machine1.monboreseau.com.

# vi /etc/namedb/master/0.1.168.192.in-addr.arpa

$ttl 86400

@ IN SOA ns1.monboreseau.com. support.monboreseau.com. (

2008040101 ;

21600 ;

3600 ;

604800 ;

86400 ) ;

@ IN NS ns1.monboreseau.com.

@ IN NS ns2.monboreseau.com.

1 IN PTR ns2.monboreseau.com.

2 IN PTR machine2.monboreseau.com.

Vous pouvez maintenant lancer votre serveur DNS primaire:

Sous GNU/Linux:

# /etc/init.d/named start

Sous BSD:

# /etc/rc.d/named start

Pour valider que le serveur marche bien, il faut se mettre sur une machine de votre réseau et utiliser la commande dig:

# dig @80.80.80.1 machine1.monboreseau.com

…

;; ANSWER SECTION:

machine1.monboreseau.com. 86400 IN A 80.80.80.1

…

Configuration du serveur secondaire

Vous voilà donc avec un serveur primaire en état de marche, pour des raisons de fiabilité et/ou de performanace, il peut être utile de disposer d’un second serveur dit secondaire sur votre réseau.

La encore nous allons utiliser le daemon named avec une configuration spécifique:

On commence par le fichier de configuration:

# vi /etc/namedb/named.conf

options {

directory “/etc/namedb”;

query-source address * port 53;

notify yes;

version “Bind”;

};

server 80.80.80.1 {

transfer-format many-answers ;

};

logging {

channel lames {

file “/var/log/named.run”;

severity debug;

};

category default { lames; };

};

zone “.” {

type hint;

file “named.root”;

};

zone “0.0.127.in-addr.arpa” IN {

type master;

file “localhost.rev”;

};

// Zone MONBORESEAU.COM

zone “monboreseau.com” {

type slave ;

file “slave/monboreseau.com” ;

masters { 80.80.80.1 ; } ;

} ;

// Zone 192.168.1.0

zone “0.1.168.192.in-addr.arpa” {

type slave ;

file “slave/0.1.168.192.in-addr.arpa” ;

masters { 80.80.80.1 ; } ;

} ;

// Zone 80.80.80.0

zone “0.80.80.80.in-addr.arpa” {

type slave ;

file “slave/0.80.80.80.in-addr.arpa” ;

masters { 80.80.80.1 ; } ;

} ;

Le téléchargement des fichiers de zones entre le serveur primaire et le serveur secondaire se fera automatiquement au démarrage du daemon named.

Vous pouvez maintenant lancer votre serveur DNS secondaire:

Sous GNU/Linux:

# /etc/init.d/named start

Sous BSD:

# /etc/rc.d/named start

Il faut d’abord vérifier que les fichiers de zones sont bien présent dans le répertoire /etc/namedb/slave/, puis pour valider que le serveur marche bien, il faut se mettre sur une machine de votre réseau et utiliser la commande dig:

# dig @192.168.29.1 machine1.monboreseau.com

…

;; ANSWER SECTION:

machine1.monboreseau.com. 86400 IN A 80.80.80.1

…

Vous voilà maintenant avec une belle architecture DNS sur votre réseau. Il ne faut pas oublier de mettre à jour régulièrement le daemon named et aussi mettre en place une sauvegarde de vos zone primaire (au cas ou…).

Installation d’Alien

# sudo apt-get install alien

Utilisation d’Alien pour installer un RPM

Par exemple, si vous souhaitez installer le package test.rpm, il suffit de taper les commandes suivantes:

# sudo alien -k test.rpm

# sudo dpkg -i test.deb

Et voili..

Ce qu’il vous faut avant de vous lancer dans l’aventure…

Une petite liste à mettre sur post-it:

• 1 eeePC
  
  
• 1 lecteur de CD-ROM externe USB (bien qu’il existe des méthodes pour installer Ubuntu à partir d’une clés USB)
  
  
• la dernière version ISO de eeeXubuntu (la version Ubuntu modifiée pour l’eeePC) gravée sur un CD

Avant de suivre la procédure d’installation suivante, il faut démarrer sous l’OS Xandros fourni en standard avec l’eeePC et activer l’interface Wifi (touche raccourcie: Fn+F2), en effet celle-ci doit être activée avant de lancer l’installation de Ubuntu.

Procédure d’installation

Rien de très original, après avoir “booter” sur le CD USB (presser plusieurs fois la touche Escape lors du démarrage de la machine pour accéder au bios), il faut sélectionner l’option eeePC et suivre l’installation standard.

Une fois le bureau de la version live de Ubuntu affiché, il faut double cliquer sur l’icône installation (”Install”). Vous avez alors le choix entre une installation sur le disque SSD interne (conseillée) ou sur une carte SD externe. Personnellement j’ai effectué l’installation sur le disque SSD interne (entier).

Le Windows Manager est XFCE, moins gourmand que Gnome.

Première configuration

Avant toutes chose, il faut mettre à jour votre système. Pour cela, il faut vous connecter à un réseau ayant accès à Internet (via un câble Ethernet ou par un réseau ouvert Wifi). La mise à jour devrait prendre un petit moment et nécessitera sûrement un redémarrage (du mois au moment de l’écriture de ce billet avec une version eeeXubuntu 7.10.3).

Si vous êtes sur un réseau qui nécessite l’utilisation d’un Proxy pour sortir sur Internet, il vous faudra ouvrir un terminal et saisir les commandes suivantes:

# export http_proxy=”http://adresseIP_de_votre_proxy:portTCP_de_votre_proxy”

# update-manager

Pour que l’installation des packages se fasse directement sur Internet et non plus via le CD ROM d’installation, il faut éditer le fichier /etc/apt/source.list et commenter la ligne suivante:

# sudo vi /etc/apt/source.list

#… cdrom …

Si vous êtes allergique à ‘vi’ vous pouvez passer par le menu Applications/Système/sources de mise à jour pour faire cette dernière opération.

Enfin il ne reste plus qu’a commenter un ligne dans le fichier /etc/fstab afin que le montage de clès USB se fasse sans problème:

# sudo vi /etc/fstab

#… /media/cdrom0 …

Pour aller plus loin…

Je ne sais pas vous mais le clavier de l’eeePC est un peu petit pour mes grosses mains. Donc quand je suis chez moi, je préfère continuer à bosser à partir de mon PC classique. Pour accéder à l’eeePC, le plus simple est d’y installer un serveur SSH:

# sudo apt-get install openssh-server

Si vous voulez installer un serveur FTP sur votre eeePC (avec un utilisateur titi), il faut faire les opérations suivantes:

# sudo apt-get install openbsd-inetd

# sudo apt-get install proftpd
> Choisir le lancement par inetd/xinetd

# sudo addgroup ftpuser

# vi /etc/proftpd/proftpd.conf
…
DefaultRoot ~ ftpuser
…

# sudo adduser titi

# sudo usermod -G ftpuser titi

La configuration de l’eeePC pour vos besoins est sans limite. Pour vous aidez dans vos premiers pas, vous pouvez consulter le Wiki suivant.

L’OS FreeBSD est très bien classé en ce qui concerne la stabilité (voir le top des uptimes ici) et la qualité de son stack IP. C’est donc un candidat idéal pour y bâtir le routeur/firewall de votre réseau. Nous allons dans ce billet faire une installation “from scratch” d’un Firewall sous FreeBSD 7.0 et la configuration des services de bases.

Installation de FreeBSD depuis les sources

On insère le CD d’installationdans le lecteur et après le démarrage sur ce média, on lance une installation de type Custom avec les caractéristiques suivantes:

Partition: on choisi une partition libre sur un disque dur. On y installe le boot manager standard

Label: on met le label SWAP sur un disque de taille 2xRAM puis le label / sur le reste du disque

Distribution: on ne chipote pas et on selectionne la distribution Developer

Media: CD

Commit: On lance l’installation

Une fois l’installation faite, on reboote et on se logue avec l’utilisateur root (ne pas oublier de changer le password grâce à la commande passwd).

On garde les ports à jour

Un “port” dans le langage FreeBSDien, est une application packagée pour cet OS. La liste des “ports” ainsi que les sources, se trouve dans le répertoire /usr/ports. Pour installer un port la méthode la plus simple est la suivante:

# pkg_add -r <nom du port>

Les puristes préféreront aller dans le répertoire /usr/ports/<categorie>/<nom du port> et faire la fameuse séquence: make install; make clean. 

Avant de commencer la configuration du Firewall, on va s’assurer que le serveur est à jour et qu’il le restera dans l’avenir (cad que les ports sont bien à jour). Pour cela, nous allons utiliser la commande Csup et les utilitaires PortUpgrade.

# pkg_add -r portupgrade

# mkdir /usr/local/etc

# mkdir /usr/local/etc/csup

# cp /usr/share/example/cvsup/ports-supfile /usr/local/etc/csup

  > Penser à éditer le fichier et à remplir le champs *default host=cvsup.fr.FreeBSD.org

# cp /usr/share/example/cvsup/stable-supfile /usr/local/etc/csup

  > Penser à éditer le fichier et à remplir le champs *default host=cvsup.fr.FreeBSD.org

# chown 644 /usr/local/etc/csup/*

# export alias cvsup=”csup”

Pour lancer une mise à jour du répertoire /usr/ports, il faut utiliser les commandes suivantes:

# /usr/bin/csup /usr/local/etc/csup/ports-supfile

# /usr/local/sbin/portsdb -Fu

La première ligne met à jour les ports, la seconde met à jour la base de donnée des ports.

Afin d’automatiser tout cela, je vous propose d’utiliser un petit crontab de famille:

# vi /usr/local/bin/daily.sh

/usr/bin/csup /usr/local/etc/csup/ports-supfile

/usr/local/sbin/portsdb -Fu

/usr/local/sbin/portversion -v -l | /usr/bin/mail support@mondomaineamoi.com

La dernière ligne du script permet d’envoyer un mail quand des ports installés ne sont plus à jour.

# crontab -e

23 0 * * * /usr/local/thales/bin/daily.sh 2>&1 >>/dev/null

et le noyau aussi…

Le noyau (ou kernel) est un élément important pour la sécurité de votre Firewall. Je vous invite à lire le billet suivant pour apprendre à le maintenir à jour.

On commence les choses sérieuses

A ce point, vous devez maintenant avoir un système à jour, près a affronter les différentes étapes pour la transformation en Firewall de compétition.

Comme on aime bien commencer par la base, nous allons d’abord recompiler le noyau (kernel) afin d’y mettre les options dont nous allons avoir besoin. Pour faire un Firewall, il faut un outil de filtrage de paquets IP. FreeBSD est fourni en standard avec PF (Packet Filter). Plus par habitude que pour des raisons cartésiennes, je lui préfère IPFW. Nous allons donc inclure les options suivantes dans le fichier de configuration du noyau (cette étape est seulement nécessaire si vous voulez faire du NAT avec votre Firewall, sinon, vous pouvez charger IPFW comme un module).

# cd /usr/src/sys/i386/conf/

# cp GENERIC FIREWALL

# vi FIREWALL

…

options    IPFIREWALL

options    IPFIREWALL_VERBOSE

options    IPFIREWALL_VERBOSE_LIMIT=5

options    IPFIREWALL_DEFAULT_TO_ACCEPT

Pour l’activation du NAT, il faut ajouter dans le même fichier, l’option suivant:

options    IPDIVERT

Enfin si vous souhaitez “router” des paquets multicast (rien que ça…) il faut ajouter l’option:

options    MROUTING

Pour recompiler le noyau, il suffit de suivre cette procédure. (il n’est pas nécessaire de faire les étapes de type world si vous ne souhaitez que recompiler le noyau)

Une fois votre nouveau kernel actif, il faut modifer le fichier de démarrage rc.conf pour lancer le Firewall et le NAT:

# vi /etc/rc.conf

…

firewall_enable=”YES”

firewall_script=”/etc/ipfw.rules”

ipnat_enable=”YES”

ipnat_script=”/etc/ipnat.rules”

En attendant un logiciel open-source équivalent…

L’OpenMac de Psystar

Pourtant en allant un peu plus loin on déchante rapidement… En effet cette machine n’est pas vendue avec un Mac OS X standard mais avec un hardware compatible avec la version pirate de Mac OS X du projet OSX86. Concrètement, les petits malins de Psystar (société distributrice de l’OpenMac) ont montés une machine en se basant sur la liste des composants compatibles OSX86. Il propose même, en option, de pré-installer la version 10.5.2 de Mac OSX en effectuant les modifications proposées par le projet OSX86.

Je ne pense pas qu’Apple apprécie trop l’initiative, en effet dans le contrat de licence de Mac OS X il est stipulé qu’il est interdit d’installer cet OS sur une machine autre qu’Apple (même avec les bidouilles proposées par le projet OSX86).

D’ailleurs au moment de l’écriture de ce billet, le site de Psystar est injoignable… victime de son succès ou bien de la pomme…

Par exemple, voici ce que donne Le Blog de Nicolargo:

En attendant de voir mon blog sur un vrai iPhone ;)…

photo credit: Locator

Pour cela, on peut :

• télécharger un OS Live existant comme celui d’Ubuntu, DSL (Damn Small Linux) ou autre
• créer son propre OS from scratch
• partir d’un OS Live existant et le customizer

La première solution est évidemment la plus simple et la plus rapide, mais ne permet pas de pré-configurer le système.

La seconde solution est la plus complète de toutes, mais nécessite de longues heures de compilation.

La troisième est un excellent compromis entre les 2 autres solutions et est celle que nous allons détailler dans ce sujet…

1. Pré-requis

Ce tutoriel a été réalisé sur une distribution Ubuntu 7.10, et nécessite les packages suivants: mkisofs, squashfs-tools, fakeroot, gfxboot, syslinux

~/# sudo apt-get install mkisofs squashfs-tools fakeroot gfxboot syslinux

Il nous faudra aussi télécharger une distribution Ubuntu, par exemple la 6.06 ou la 7.10. Ce tutoriel se base sur la Ubuntu Desktop 6.06, mais marche très bien avec les versions supérieures.

On se créera aussi un répertoire de travail sur le système, par exemple ~/SANDBOX

~/# mkdir ~/SANDBOX

2. Préparation de l’environnement

Tout d’abord, il va falloir monter le fichier ISO de la distribution choisie dans un répertoire sur le disque, par exemple /mnt/ubuntu

~/# sudo mkdir /mnt/ubuntu
~/# sudo mount -t iso9660 -o loop /chemin/vers/ubuntu-6.06-desktop-i386.iso /mnt/ubuntu

puis copier intégralement le contenu du CD dans le repertoire de travail ~/SANDBOX/livecd et récupérer les droits d’écriture sur toute l’arborescence

~/# cd ~/SANDBOX
~/SANDBOX/# mkdir livecd
~/SANDBOX/# sudo cp -a /mnt/ubuntu/* livecd
~/SANDBOX/# sudo chmod -R u+w livecd
~/SANDBOX/# sudo umount /mnt/ubuntu

La majorité des fichiers visibles du disque sert pour la phase de boot du systeme. Seul le fichier livecd/casper/filesystem.squashfs contient la racine système chargé en mémoire par le live CD. Nous allons donc le monter dans notre repertoire ~/SANDBOX/old-filesystem en lecture seule

~/SANDBOX/# mkdir old-filesystem
~/SANDBOX/# sudo mount -t squashfs -o loop,ro livecd/casper/filesystem.squashfs old-filesystem

Désormais, le répertoire ~/SANDBOX/old-filesystem contient la racine du systeme de fichiers de la distribution live. Un petit coup de “du -cs old-filesystem” nous montre que ce systeme occupe presque 2Go sur le disque ! Il nous faut donc réserver 2Go d’espace supplémentaire pour le nouveau systeme de fichiers…

~/SANDBOX/# dd if=/dev/zero of=myfs.ext2 bs=1M count=2147

… on va ensuite formater ce nouveau systeme de fichiers en EXT2 (mke2fs va afficher un message d’avertissement, le valider)…

~/SANDBOX/# mke2fs myfs.ext2

… puis on va monter ce tout nouveau systeme de fichiers en lecture/ecriture dans le repertoire ~/SANDBOX/new-filesystem

~/SANDBOX/# mkdir new-filesystem
~/SANDBOX/# sudo mount -o loop myfs.ext2 new-filesystem

Maintenant on peut copier le systeme de fichiers originel dans l’espace réservé au nouveau afin de pouvoir lui appliquer toutes les modifications souhaitées

~/SANDBOX/# sudo cp -a old-filesystem/* new-filesystem/

Avant de procéder aux modifications réelles du nouveau systeme, on va tout d’abord récupérer la configuration DNS de notre machine ainsi que “binder” le répertoire /proc sur le nouveau systeme

~/SANDBOX/# sudo cp /etc/resolv.conf new-filesystem/etc
~/SANDBOX/# sudo mount -t proc -o bind /proc new-filesystem/proc
~/SANDBOX/# sudo mount -t sys -o bind /proc new-filesystem/sys
~/SANDBOX/# sudo mount -t devpts -o bind /proc new-filesystem/dev/pts

3. Go-go-gadget au chroot & installation de nouveaux logiciels

Maintenant que tout est prêt, c’est parti pour le CHROOT : on va lancer un shell (bash par exemple) en spécifiant le répertoire “~/SANDBOX/new-filesystem” comme la racine du systeme.

~/SANDBOX/# sudo chroot new-filesystem /bin/bash

Désormais, “ls -l /” listera les fichiers contenus dans la nouvelle racine (et non la vraie racine de votre systeme), et un “ps aux” sur ce shell listera les processus du nouveau systeme ainsi que ceux du système englobant. Tout se passe donc a peu près comme si on avait booté sur le nouveau système, avec quelques processus en plus !

Avant de continuer, on va changer la variable d’environnement $HOME pour qu’elle pointe vers /root

# export HOME=/root # export LC_ALL=C

Maintenant on peut y aller ! On va commencer par mettre a jour la liste des paquets aptitude…

# aptitude update

…puis lister les packages installés…

# dpkg-query -W –showformat=’${Package}\n’ | sort | less

…et supprimer les packages non utilisés avec une recherche : copier et executer le resultat de la commande

# dpkg-query -W “gnome-*” | awk ‘BEGIN {printf “apt-get remove –purge “;} // { printf $1″ “; } END { print “\n”}’

ou taper les commandes à la main

# apt-get remove –purge gnome-~n compiz-~n language-pack-gnome-~n
# apt-get remove –purge “gimp*”
# apt-get remove –purge java-common
# apt-get remove –purge “mysql*”
# apt-get remove –purge “openoffice*”

Ensuite, on va installer de nouveaux logiciels

# apt-get install xfce4-panel xfce4-utils xfce4-quicklauncher-plugin xfce4-terminal xfce4-xkb-plugin
# apt-get install xfwm4 xfwm4-themes xfce4-mcs-manager
# apt-get install gdm
# …….

Avant de terminer, on va supprimer tous les fichiers temporaires téléchargés par apt et vider le répertoire /tmp

# apt-get clean
# rm -rf /tmp/*

Sortir du système avec la commande:

# exit

4. Finalisation du nouveau systeme

Commencer par dé-monter le repertoire new-filesystem/proc

~/SANDBOX/# sudo umount new-filesystem/proc
~/SANDBOX/# sudo umount new-filesystem/sys
~/SANDBOX/# sudo umount new-filesystem/dev/pts

Supprimer la configuration DNS du nouveau systeme

~/SANDBOX/# sudo rm new-filesystem/etc/resolv.conf

Mettre a jour le fichier MANIFEST qui reflete la liste des packages installés

~/SANDBOX/# sudo chroot new-filesystem dpkg-query -W –showformat=’${Package} ${Version}\n’ > ~/SANDBOX/livecd/casper/filesystem.manifest

Maintenant, on va nettoyer l’image du systeme de fichiers en remplissant de zeros tout l’espace non occupé afin d’optimiser la compression de l’image

~/SANDBOX/# dd if=/dev/zero of=new-filesystem/dummy

On peut maintenant supprimer le fichier dummy

~/SANDBOX/# rm new-filesystem/dummy

On va ensuite construire un fichier correspondant à notre systeme de fichiers compressé

~/SANDBOX/# rm livecd/casper/filesystem.squashfs
~/SANDBOX/# cd new-filesystem
~/SANDBOX/# sudo mksquashfs . ~/SANDBOX/livecd/casper/filesystem.squashfs

prendre un café…Démonter les systèmes de fichiers précédemment montés

~/SANDBOX/# sudo umount new-filesystem
~/SANDBOX/# sudo umount old-filesystem

5. Creation du live CD

Généralement, il y a quelques fichiers et répertoires inutiles sur les distributions live, donc on va supprimer tout ce qui n’est pas nécessaire

~/SANDBOX/# cd livecd
~/SANDBOX/livecd/# rm -rf bin
~/SANDBOX/livecd/# rm -rf programs
~/SANDBOX/livecd/# rm start.exe autorun.inf start.ini start.bmp

Maintenant on peut modifier le script de démarrage afin de personnaliser l’écran d’accueil

~/SANDBOX/livecd# cd isolinux
~/SANDBOX/livecd/isolinux# vim isolinux.cfg

Pour changer la couleur de l’écran de boot (notamment la couleur de la jauge et du texte), changer la valeur hexadécimale de la ligne appropriée, exemple (pour une couleur blanche):

GFXBOOT-BACKGROUND 0XFFFFFF

et on ajouter ou modifier les labels présents, et modifier les options de boot, exemple:

LABEL livemenu
label ^Start MY GREAT OS
kernel /casper/vmlinuz
append boot=casper initrd=/casper/initrd.gz ramdisk_size=1048576 root=/dev/ram rw quiet splash vga=791 –

Pour modifier le logo de l’écran de démarrage, il faut éditer (avec The Gimp ou Paint.net) l’image ~/SANDBOX/livecd/isolinux/splash.pcx

Pour modifier l’image de splash, affichée lors du chargement du système il va falloir éditer l’image ~/SANDBOX/livecd/isolinux/splash.rle‘ : c’est une image de type LSS16 qui a une résolution de 640×480 pixels avec 16 couleurs indexées. Pour la modifier, il faut la convertir en un format lisible par The Gimp ou Paint.net avec la commande ppmtolss16 :

~/SANDBOX/livecd/isolinux# lss16toppm < splash.rle > splash.ppm

Apres l’avoir modifiée, la reconvertir en format LSS16 avec la commande ppmtolss16 :

~/SANDBOX/livecd/isolinux# ppmtolss16 < splash.ppm > splash.rle

Maintenant on va regénérer l’empreinte MD5 du CD (obligatoire)

~/SANDBOX/livecd/# sudo find . -type f -print0 | xargs -0 md5sum | sudo tee md5sum.txt

Et pour terminer, on va créer l’ISO de notre LiveCD !

~/SANDBOX/livecd/# cd ..
~/SANDBOX/# sudo mkisofs -o MyLiveCD.iso -b isolinux/isolinux.bin -c isolinux/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table -r -V “Custom Ubuntu Live CD” -cache-inodes -J -l livecd

Il ne reste plus qu’a graver cette image ISO sur un CD et rebooter pour tester tout ca (pour éviter de rebooter, on peut installer VirtualBox aussi…) !

6. Creation du live USB

Un CD c’est bien, mais une clé USB c’est mieux (encore faut-il pouvoir booter dessus) !. Pour cela il faut créer 2 partitions sur la clé :

• une pour l’os
• et une autre qui sera utilisée pour la persistence des données (c’est l’avantage par rapport au CD…)

Tout d’abord brancher la clé usb, puis regarder le nom de device que lui a attribué le kernel

~/SANDBOX/# fdisk -l

Supposons que ce soit /dev/sdb, alors les partitions de ce devices auront alors pour nom /dev/sdb1, /dev/sdb2, etc.

# fdisk /dev/sdb

puis entrer les commandes suivantes:

p (pour afficher la liste des partitions)
d (pour supprimer la ou les partitions)
p (pour lister les partitions restantes : appuyer sur d pour les supprimer alors)
n (pour créer une nouvelle partition)
p (pour créer une partition primaire)
1 (pour faire en sorte que ce soit la premiere partition)
1 ou entrée (pour choisir le premier cylindre)
+1024M (pour choisir la taille de la partition principale, à adapter selon la taille de votre liveCD et de votre clé USB)
a (pour activer la partition)
1 (pour choisir d’activer la partition que l’on vient de créer)
t (pour choisir le système de fichiers de la partition)
6 (pour choisir FAT16)
n (pour créer la deuxième partition)
p (partition primaire)
2 (numéro de la partition)
entrée (choix par défaut pour le premier cylindre)
entrée (choix par défaut pour le dernier cylindre)
w (pour ecrire les changements sur la partition)

Démonter ensuite les partitions montées de la clé

~/SANDBOX/# sudo umount /dev/sdb1

Puis il faut formatter les deux partitions:

~/SANDBOX/# mkfs.vfat -F 16 -n MyUSBOS /dev/sdb1
~/SANDBOX/# mkfs.ext2 -b 4096 -L casper-rw /dev/sdb2

Maintenant, on peut recopier le contenu du livecd sur la premiere partition de la clé

~/SANDBOX/# sudo mkdir -p /mnt/liveusb{1,2}
~/SANDBOX/# mount /dev/sdb1 /mnt/liveusb1
~/SANDBOX/# sudo cp -r ~/SANDBOX/livecd/* /mnt/liveusb1

Copier les images splash .rle et .pcx du répertoire isolinux a la racine…

~/SANDBOX/# sudo cp /mnt/liveusb1/isolinux/splash.{rle,pcx} /mnt/liveusb1

Copier le fichier isolinux/isolinux.txt a la racine et le renommer en syslinux.txt

~/SANDBOX/# sudo cp /mnt/liveusb1/isolinux/isolinux.txt /mnt/liveusb1/syslinux.txt

Créer un fichier nommé syslinux.cfg (qui permet de configurer syslinux) a la racine…

~/SANDBOX/# touch /mnt/liveusb1/syslinux.cfg

… et le remplir avec la configuration de base suivante:

DEFAULT /casper/vmlinuz
GFXBOOT /casper/bootlogo
GFXBOOT-BACKGROUND 0×678db2
APPEND boot=casper initrd=/casper/initrd.gz quiet splash –
LABEL persistent
kernel /casper/vmlinuz
append boot=casper persistent initrd=/casper/initrd.gz quiet splash –
LABEL live
kernel /casper/vmlinuz
append boot=casper initrd=/casper/initrd.gz quiet splash –
LABEL memtest
kernel /install/mt86plus
append -
LABEL hd
localboot 0×80
append -
DISPLAY syslinux.txt
TIMEOUT 300
PROMPT 1

A noter que le label “persistent” ajoute un parametre du meme nom au kernel qui permettra de monter la deuxième partition en lecture/ecriture.

Ne pas oublier ensuite de regénérer l’empreinte MD5 :

~/SANDBOX/# cd /mnt/liveusb1
/mnt/liveusb1# sudo find . -type f -print0 | xargs -0 md5sum | sudo tee md5sum.txt
/mnt/liveusb1# cd -

Et finalement rendre la clé bootable avec syslinux

~/SANDBOX/# syslinux -sf /dev/sdb1

Et voila, vous pouvez maintenant conquérir le monde avec votre clé USB et votre CD bootables !

Voici les articles dont je me suis largement inspiré pour écrire ce post, merci à eux:

• https://help.ubuntu.com/community/LiveCDCustomization
• http://www.atworkonline.it/~bibe/ubuntu/custom-livecd.htm
• http://michauko.org/blog/2008/02/20/ubuntu-xubuntu-en-fait-persistant-sur-clef-usb/
• http://www.pendrivelinux.com/

NDNicolargo: un grand merci à Nicolas Richasse pour cet article !