Ton phacochère [1] familier, bien que très sympathique, continue de faire quelques bêtises dans ta maison, bouffer les meubles, vider sa gamelle un peu partout, voire embêter tes autres colocataires.
Ne voulant pas te résoudre à l’enfermer dans une niche (chroot) trop étroite, tu décides de lui construire un enclos qui lui sera dédié et dans lequel il pourra faire ce que bon lui semble sans nuire à son entourage (continue to be root).
Pré-requis
- un terrain propice (avoir un FreeBSD sous la main, être root dessus) ;
- un peu d’espace disque, car on va dupliquer tout le userland dans l’enclos ;
- avoir les sources dans /usr/src.
Avant d'envisager la construction
Avant de pouvoir configurer son enclos (
jail), il faut déjà préparer le terrain tout autour (configurer le serveur qui va accueillir les jails pour que les daemons n’écoutent plus sur toutes les IP).
Donc, tout autour de l’emplacement de son futur enclos, on fixe les branches qui dépassent, on ramasse les feuilles mortes, on passe un coup de râteau et on laisse un emplacement le plus nickel possible.
- sshd
Utilisez sshd_flags=”-oListenAddress=Public_IP” dans votre fichier /etc/rc.conf ou modifiez /etc/ssh/sshd_config (et redémarrez le daemon sshd par /etc/rc.d/sshd restart)
Ajoutez DAEMON_OPTIONS(Addr=Public_IP’) à votre fichier de macro sendmail (fichier mc)
Si vous utilisez inetd, il faut ajouter inetd_flags=”-a Public_IP” à votre /etc/rc.conf (attention à bien reprendre les flags existants).
Utilisez la directive listen-on { Public_IP; }; dans votre fichier de configuration named.conf.
Utilisez la directive Listen Public_IP:80 dans votre /usr/local/etc/httpd.conf
Idem pour les autres daemons écoutant sur toutes les IP.
Un enclos en kit
Tu as acheté ton enclos au même endroit que ton abri de jardin et, bien aimablement, le fabricant a fourni une aide minimale au montage des différents éléments ; pourtant, tout n’est pas aussi simple que chez Ikea. Tu n’auras pas de notice imprimée recto-verso t’expliquant ce qu’est une vis, mais cela ne signifie pas qu’il n’y a pas de documentation !
Extrait de la page de man de
jail [2]
|
|
EXAMPLES
Setting up a Jail Directory Tree
To set up a jail directory tree containing an entire FreeBSD
distribution, the following sh(1) command script can be used:
D=/here/is/the/jail
cd /usr/src
mkdir -p $D
make world DESTDIR=$D
make distribution DESTDIR=$D
mount_devfs devfs $D/dev |
Si tu as compilé ton système récemment, tu peux remplacer
make world DESTDIR=$D par
make installworld DESTDIR=$D ce qui te fera économiser tout le temps de la compilation.
Une méthode plus Gruik consiste à monter une image ISO de FreeBSD et à extraire l’environnement de base comme s’il s’agissait d’une installation d’un système :
|
|
# ggatel create 6.2-RELEASE-i386-disc1.iso
ggate0
# mount -t cd9660 /dev/ggate0 /mnt
# cd /mnt/6.2-RELEASE/base
# mkdir -p /home/jails/gcujail
# cat base.?? | tar --unlink -vxpzf - -C /home/jails/gcujail |
On va créer manuellement le
/dev/* du jail et y "entrer" :
|
|
# mount_devfs devfs /home/jails/gcujail/dev
# jail -l -U root /home/jails/gcujail gcujail 127.0.0.1 /bin/csh |
On regarde un peu dans quel environnement on se retrouve :
|
|
gcujail# uname -a
FreeBSD gcujail 7.0-CURRENT FreeBSD 7.0-CURRENT #33: Sat Mar 17 19:35:45 CET 2007 root@stealth.domain.tld:/usr/obj/usr/src/sys/STEALTH i386
gcujail# ls -al
-rw-r--r-- 2 root wheel 801 Jan 12 07:42 .cshrc
-rw-r--r-- 2 root wheel 251 Jan 12 07:42 .profile
-r--r--r-- 1 root wheel 6196 Jan 12 07:42 COPYRIGHT
drwxr-xr-x 2 root wheel 1024 Jan 12 07:41 bin
drwxr-xr-x 5 root wheel 512 Jan 12 07:42 boot
[snip]
gcujail# mount
/dev/ad0s1f on / (ufs, local, soft-updates) |
On s’aperçoit que le système dans le jail hérite de la version du kernel du serveur hôte malgré le userland "décalé" et que la sortie de la commande
mount ne montre que la partition accueillant le jail.
De même, depuis le jail, la commande
uptime montre le résultat du serveur hôte et pas du jail en lui-même.
Pour vous en convaincre, créez le fichier
/etc/rc.local contenant
|
|
echo </code>date` >> /root/boot.log |
dans le jail ; amusez-vous à faire plusieurs reboot et regarder le fichier de log et l’uptime.
Pour le moment, le user
root du jail voit tout
/dev à l’identique de ce qu’il se trouve sur le serveur hôte, ce qui peut être très dangereux si vous n’avez pas confiance dans le root du jail, car il a accès à tous les disques et partitions, à la configuration de vos règles de firewall...
Et la barrière électrique ?
Dans un jail correctement configuré comme plus loin dans l’article, le root du jail ne peut pas configurer son propre firewall et, par conséquent, il ne peut pas choisir et setter ses rules.
|
|
# pfctl -s rules
pfctl: /dev/pf: No such file or directory |
Toute la configuration firewall se fait "au-dessus" du jail, sur le serveur hôte.
Configuration par défaut
Le système FreeBSD comporte une configuration par défaut et des exemples pour configurer votre/(vos) jail(s).
Ces informations se trouvent dans
/etc/defaults/rc.conf qui est lu par les scripts de démarrage ; toutes les modifications doivent se faire dans
/etc/rc.conf.
Voici les paramètres communs à tous les jails :
|
|
##############################################################
### Jail Configuration #######################################
##############################################################
jail_enable="NO" # Set to NO to disable starting of any jails
jail_list="" # Space separated list of names of jails
jail_set_hostname_allow="YES" # Allow root user in a jail to change its hostname
jail_socket_unixiproute_only="YES" # Route only TCP/IP within a jail
jail_sysvipc_allow="NO" # Allow SystemV IPC use from within a jail |
Et voici la liste des paramètres spécifiques à un jail qui peuvent être repris pour la configuration de vos jails :
Voir Figure 1,
Configurons notre enclos
Voici ce que j’ai mis dans le
/etc/rc.conf du serveur hôte ; l’utilisation de chaque variable sera détaillée plus loin.
|
|
# jail
jail_enable="YES"
jail_list="gcujail"
# Emplacement du jail et son hostname
jail_gcujail_rootdir="/home/jails/gcujail"
jail_gcujail_hostname="gcujail.gcu.info"
# ip du jail et interface qui portera l'alias
jail_gcujail_ip="192.168.0.10"
jail_gcujail_interface="bge0"
# on veut un /dev restreint dans le jail
jail_gcujail_devfs_enable="YES"
jail_gcujail_devfs_ruleset="devfsrules_jail"
# l'option -J permettra d'avoir des informations sur le jail
jail_gcujail_flags="-l -U root -s 1 -J /var/run/jail_gcujail.jid" |
Dans le
rc.conf du jail, on lui indique de démarrer
sshd comme d’habitude :
|
|
sshd_enable="YES"
sendmail_enable="NONE" |
Apparemment, il n’est plus indispensable de commenter
adjkerntz -a dans
/etc/crontab du système jailé.
Démarrons ce jail et regardons ce qui est vu du serveur hôte.
|
|
# /etc/rc.d/jail start gcujail
Configuring jails:.
Starting jails: gcujail.gcu.info.
# ifconfig bge0
bge0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
options=98<VLAN_MTU,VLAN_HWTAGGING,VLAN_HWCSUM>
[snip]
inet 192.168.0.10 netmask 0xffffffff broadcast 192.168.0.10
# mount
[snip]
devfs on /home/jails/gcujail/dev (devfs, local) |
Ce qu’il s’est produit :
- l’alias IP 192.168.0.10 est automatiquement ajouté sur l’interface précisée par jail_gcujail_ip ;
- devfs s’occupe de monter le /dev du jail au démarrage de celui-ci ;
- les devices visibles dans le /dev du jail ont réduit comme peau de chagrin et ne permettent plus d’outrepasser les devices sur le serveur hôte (faites un ls pour vérifier).
Voir Figure 2
Vous aurez remarqué que le jail est démarré en
securelevel [3] à 1 grâce à
-s 1 de la variable
jail_gcujail_flags.
Les logs
Activons les logs de la console dans le jail (fichier
/home/jails/gcujail/etc/syslog.conf) :
|
|
console.info;*.err;kern.warning;auth.notice /var/log/console.log |
Créons le fichier en question et redémarrons le jail :
|
|
# touch /home/jails/gcujail/var/log/console.log
# /etc/rc.d/jail restart |
Ce qui aura pour effet de créer un fichier
/var/log/jail_gcujail_console.log sur le serveur hôte reprenant les logs de la console.
Remplir l'enclos
Afin d’économiser un peu d’espace disque, il vous semble évident que vous allez limiter au strict minimum les informations dupliquées sur le serveur hôte ainsi que dans votre (vos) jail(s).
Typiquement, on partage
/usr/src et /usr/ports :
|
|
# mount -t nullfs -o ro /usr/src /home/jails/gcujail/usr/src
# mount -t nullfs -o ro /usr/ports /home/jails/gcujail/usr/ports
# mount | grep nullfs
/usr/src on /home/jails/gcujail/usr/src (nullfs, local, read-only)
/usr/ports on /home/jails/gcujail/usr/ports (nullfs, local, read-only) |
Il est possible d’ajouter ces points de montage dans le
/etc/fstab du serveur hôte afin que le jail y ait accès de manière permanente, mais attention, ces répertoires peuvent être supprimés depuis le jail !
Pour plus de sécurité, il est recommandé de monter
/usr/src et
/usr/ports/ en read-only dans le jail et de modifier la manière dont sont compilés les ports à partir du jail (pour pouvoir utiliser un
/usr/ports en RO).
Si vous devez gérer plusieurs enclos, il est préférable de mettre en place un export NFS en read-only de ces répertoires vers les jails, ce qui évitera les points de montage en
nullfs :
|
|
# mkdir -p /usr/obj/portsbuild /usr/obj/distfiles |
Et on édite le
/etc/make.conf du jail pour y ajouter les lignes suivantes :
|
|
WRKDIR=/usr/obj/portsbuild
DISTDIR=/usr/obj/distfiles |
Il suffit d’ajouter les ports dans le jail comme d’habitude. Ceci aura pour inconvénient d’ignorer le contenu de
/usr/ports/distfiles ; n’hésitez pas à en recopier les fichiers s’ils existent, ce qui évitera de perdre de la bande passante et du temps.
Pensez à faire régulièrement le ménage dans
/usr/obj/distfiles du jail sans quoi de l’espace disque sera perdu pour rien.
Sécuri-clos
Au cours de l’installation du jail, tu as constaté qu’il tenait sur une seule partition, ce qui est assez gênant quand tu veux avoir des points de montage avec des droits différents.
Par exemple, j’ai pris pour habitude d’utiliser un
/tmp de taille fixe, monté en RAM, avec des droits
noexec et
nosuid.
Habituellement, je déclare dans
/etc/rc.conf les lignes suivantes :
|
|
tmpmfs="YES"
tmpsize="512m"
tmpmfs_flags="-S -o noexec,nosuid" |
qui ont pour résultat :
|
|
# mount | grep tmp
/dev/md0 on /tmp (ufs, local, noexec, nosuid) |
Mais cela ne fonctionne pas dans
gcujail tout simplement parce que les commandes
mdconfig n’ont pas accès aux devices /dev/md* depuis le jail !
Les ajouter serait une fausse bonne idée, puisque cela donnerait accès aux devices
md* appartenant au serveur hôte depuis l’intérieur du jail.
Oh, tu peux essayer de bricoler le
/etc/fstab du jail, si tu arrives à quelque chose de concluant tu es prié d’écrire à Pinpin (ou à l’auteur).
La solution, peu gracieuse, trouvée pour l’instant, est la suivante :
- sur le serveur hôte, on crée un fichier vide d’une taille fixe :
|
|
# dd if=/dev/zero of=/home/jails/gcujail.tmp bs=1m count=512
512+0 records in
512+0 records out
536870912 bytes transferred |
Edition du fichier
/etc/fstab.gcujail (qui sera pris par défaut par le script
jail) :
Voir Figure 3
et on ajoute la gestion du
mount dans le fichier
/etc/rc.conf du serveur hôte pour ce jail :
|
|
jail_gcujail_mount_enable="YES" |
Par défaut, le fichier
fstab du jail pris en compte par la variable
jail_gcujail_fstab sera
/etc/fstab.gcujail.
On redémarre le jail :
|
|
# /etc/rc.d/jail restart
# mount | grep md
/dev/md1 on /home/jails/gcujail/tmp (ufs, local, noexec, nosuid) |
Le
/tmp de notre jail est bien d’une taille limitée et monté avec des droits moins permissifs.
Note
Un inconvénient de cette méthode est que bien qu’un /etc/rc.d/jail stop démonte le /tmp du jail, cela ne libère pas le device md qui y était associé et il faut le faire à la mimine depuis le serveur hôte !
Quota-clos
Jusqu’à présent, ton phacochère est tout seul dans son enclos. Il peut le décorer comme il lui plaît et ajouter ce dont il a besoin, mais, surtout, il peut continuer à prendre tout l’espace disponible dans son enclos.
Il y a au moins deux solutions pour résoudre ce problème :
- mettre les répertoires accueillant les jails dans des partitions physiques et donc de taille fixe ;
- utiliser l’astuce d’un filesystem sur un fichier comme ce qu’on a fait avec /home/jails/gcujail.tmp, ce système de fichiers étant monté depuis le système hôte avant le démarrage du jail.
Manager plusieurs enclos
Divers programmes sont disponibles dans les ports afin de manager plusieurs jails plus facilement, liste évidemment non exhaustive :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
# make search name=jail | grep -E "^Port|^Path|^Info"
Port: jailaudit-1.2
Path: /usr/ports/security/jailaudit
Info: Script to generate portaudit reports for jails
Port: ezjail-2.0.1
Path: /usr/ports/sysutils/ezjail
Info: A framework to easily create, manipulate and run FreeBSD jails
Port: jailadmin-1.8_2
Path: /usr/ports/sysutils/jailadmin
Info: A system for managing a set of named jails
Port: jailctl-0.71
Path: /usr/ports/sysutils/jailctl
Info: Jail management tool
Port: jailer-1.1.2
Path: /usr/ports/sysutils/jailer
Info: Manage FreeBSD jail startup, shutdown and console
Port: jailuser-1.9_1
Path: /usr/ports/sysutils/jailuser
Info: Builds a chrooted environment
Port: jailutils-1.0
Path: /usr/ports/sysutils/jailutils
Info: Several utilities for managing jails
Port: p5-BSD-Jail-Object-0.02
Path: /usr/ports/sysutils/p5-BSD-Jail-Object
Info: An object oriented perl interface to jail(2) |
Pour une gestion plus facile des jails depuis le serveur hôte, je conseille l’installation des ports
jailadmin et
jailutils ; l’upgrade des enclos se fait de la même manière qu’un serveur FreeBSD (y compris pour le
mergemaster) sauf qu’on change la variable
$DESTDIR pour pointer dans le répertoire du jail à mettre à jour.
Figure 1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
#
# To use rc's built-in jail infrastructure create entries for
# each jail, specified in jail_list, with the following variables.
# NOTES:
# - replace 'example' with the jail's name.
# - except rootdir, hostname and ip, all of the following variables may be made
# global jail variables if you don't specify a jail name (ie. jail_interface).
#
#jail_example_rootdir="/usr/jail/default" # Jail's root directory
#jail_example_hostname="default.domain.com" # Jail's hostname
#jail_example_ip="192.168.0.10" # Jail's IP number
#jail_example_interface="" # Interface to create the IP alias on
#jail_example_exec_start="/bin/sh /etc/rc" # command to execute in jail for starting
#jail_example_exec_afterstart0="/bin/sh command" # command to execute after the one for
# starting the jail. More than one can be
# specified using a trailing number
#jail_example_exec_stop="/bin/sh /etc/rc.shutdown" # command to execute in jail for stopping
#jail_example_devfs_enable="NO" # mount devfs in the jail
#jail_example_fdescfs_enable="NO" # mount fdescfs in the jail
#jail_example_procfs_enable="NO" # mount procfs in jail
#jail_example_mount_enable="NO" # mount/umount jail's fs
#jail_example_devfs_ruleset="ruleset_name" # devfs ruleset to apply to jail
#jail_example_fstab="" # fstab(5) for mount/umount
#jail_example_flags="-l -U root" # flags for jail(8) |
Figure 2
|
|
# jls
JID IP Address Hostname Path
6 192.168.0.10 gcujail.gcu.info /home/jails/gcujail
# ps auxwww | grep J
root 2392 0.0 0.1 1376 1052 ?? SsJ 8:06PM 0:00.00 /usr/sbin/syslogd -s
root 2448 0.0 0.3 3524 3084 ?? IsJ 8:06PM 0:00.00 /usr/sbin/sshd
root 2455 0.0 0.1 1388 1064 ?? IsJ 8:06PM 0:00.00 /usr/sbin/cron -s |
Figure 3
|
|
# Device Mountpoint FStype Options Dump Pass#
md /home/jails/gcujail/tmp mfs rw,-S,noexec,nosuid,-F/home/jails/gcujail.tmp 2 0 |
Conclusion
Et voici un petit tour d’horizon sur les jails avec, je l’espère, une présentation qui sort un peu des howtos classiques qu’on trouve sur différents sites web.
Références
[1] http://fr.wikipedia.org/wiki/Phacochère
[2] http://www.freebsd.org/cgi/man.cgi?query=jail&sektion=8
[3] http://www.freebsd.org/cgi/man.cgi?query=securelevel&sektion=8 
