Le Grim-O-Wiki linux

Apache avec Virtual Hosts sur Debian

2010-05-06T15:26:16+00:00

Ce sujet est très bien documenté sur le Net, par contre le faire à la façon Debian est plus rare, surtout quand on ne parle pas anglais.

Installation

Pour installer Apache, c'est très simple : le paquet apache2 contient tout ce qu'il faut. Ensuite, Apache a une architecture modulaire, on peut donc ajouter des modules disponibles dans des paquets dont le nom est libapache2-<nom du module>

# aptitude install apache2

Sous Debian, les répertoires importants sont :

/etc/apache2: contient la configuration
/var/www: contient la racine de l'arborescence accessible par défaut
/var/log/apache2: contient les logs

Configuration

Changer le vhost par default de /var/www vers /var/www/default (vhost, repertoires, logs, logrotate)
Créer un patron de vhost
Configurer des vhosts

Changement de disque utilisé en RAID1 soft

2010-05-24T10:58:04+00:00

Sur un serveur installé en Debian Lenny, quand un disque est cassé et qu'on a du RAID1, on peut le remplacer tandis que la machine continue de travailler. Mais voilà, il faut lui dire qu'on change le disque et quand on a du SCSI, tout peut se faire à chaud.

Voici la situation des disques et du RAID soft sur le serveur au moment du crash:

Un disque SCSI de 36Go nommé /dev/sda, il est en panne et va être remplacé
Un disque SCSI de 73Go nommé /dev/sdb
4 miroirs (RAID1) en md utilisant des partitions de tailles identiques sur chaque disque

L'article sur le NAS maison montre comment configurer du RAID soft, on ne parlera donc pas de la configuration initiale du RAID. D'ailleurs, la configuration RAID de la machine prise en exemple a été faite lors de l'installation de Debian Lenny.

Les tables de partitions :

# fdisk -l

Disk /dev/sdb: 73.4 GB, 73407865856 bytes
255 heads, 63 sectors/track, 8924 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x000bd94b

   Device Boot      Start         End      Blocks   Id  System
/dev/sdb1               1         608     4883728+  fd  Linux raid autodetect
/dev/sdb2             609         851     1951897+  fd  Linux raid autodetect
/dev/sdb3             852        1094     1951897+  fd  Linux raid autodetect
/dev/sdb4            1095        8924    62894475    5  Extended
/dev/sdb5            1095        4425    26756226   fd  Linux raid autodetect
/dev/sdb6            4426        8924    36138186   83  Linux

Disk /dev/md0: 5000 MB, 5000855552 bytes
2 heads, 4 sectors/track, 1220912 cylinders
Units = cylinders of 8 * 512 = 4096 bytes
Disk identifier: 0x00000000

Disk /dev/md0 doesn't contain a valid partition table

Disk /dev/md1: 1998 MB, 1998651392 bytes
2 heads, 4 sectors/track, 487952 cylinders
Units = cylinders of 8 * 512 = 4096 bytes
Disk identifier: 0x00000000

Disk /dev/md1 doesn't contain a valid partition table

Disk /dev/md2: 1998 MB, 1998651392 bytes
2 heads, 4 sectors/track, 487952 cylinders
Units = cylinders of 8 * 512 = 4096 bytes
Disk identifier: 0x00000000

Disk /dev/md2 doesn't contain a valid partition table

Disk /dev/md3: 27.3 GB, 27398307840 bytes
2 heads, 4 sectors/track, 6689040 cylinders
Units = cylinders of 8 * 512 = 4096 bytes
Disk identifier: 0x00000000

Disk /dev/md3 doesn't contain a valid partition table

On remarque :

On ne voit plus /dev/sda
Comme sdb fait 73Go, l'excédant est utilisé pour une partition logique sdb6
Le type de partition est “Linux raid autodetect” pour pouvoir les mettre dans des raid soft.

Voici le status du RAID soft:

# cat /proc/mdstat 
Personalities : [raid1] 
md3 : active raid1 sda4[2](F) sdb5[1]
      26756160 blocks [2/1] [_U]
      
md2 : active raid1 sda3[2](F) sdb3[1]
      1951808 blocks [2/1] [_U]
      
md1 : active raid1 sda2[2](F) sdb2[1]
      1951808 blocks [2/1] [_U]
      
md0 : active raid1 sda1[2](F) sdb1[1]
      4883648 blocks [2/1] [_U]
      
unused devices: <none>

Remplacement et détection du nouveau disque

Le fait d'arracher l'ancien disque et mettre le nouveau à la place ne fait rien. Il faut dire au noyau de rescanner le bus SCSI. Des outils sympathiques pour faire ça sont fournis dans le paquet scsitools :

# aptitude install scsitools

On utilise le script rescan-scsi-bus.sh fraichement installé pour rescanner le bus SCSI, en lui demandant de supprimer ce qui a disparu, ce qui donne quelque chose proche de :

# rescan-scsi-bus.sh -r
Host adapter 0 (aic79xx) found.
Host adapter 1 (aic79xx) found.
Scanning SCSI subsystem for new devices
 and remove devices that have disappeared
Scanning host 0 channels 0 for  SCSI target IDs  0 1 2 3 4 5 6 7, all LUNs
Scanning host 1 channels 0 for  SCSI target IDs  0 1 2 3 4 5 6 7, all LUNs
Scanning for device 1 0 0 0 ...
OLD: Host: scsi1 Channel: 00 Id: 00 Lun: 00
      Vendor: SEAGATE  Model: ST336607LSUN36G  Rev: 0307
      Type:   Direct-Access                    ANSI  SCSI revision: 03
NEW: Host: scsi1 Channel: 00 Id: 00 Lun: 00
      Vendor: SEAGATE  Model: ST336607LSUN36G  Rev: 0707
      Type:   Direct-Access                    ANSI SCSI revision: 03
Scanning for device 1 0 1 0 ...
OLD: Host: scsi1 Channel: 00 Id: 01 Lun: 00
      Vendor: SEAGATE  Model: ST373307LSUN72G  Rev: 0707
      Type:   Direct-Access                    ANSI SCSI revision: 03
Scanning for device 1 0 6 0 ...
OLD: Host: scsi1 Channel: 00 Id: 06 Lun: 00
      Vendor: ESG-SHV  Model: SCA HSBP M18     Rev: 0.07
      Type:   Processor                        ANSI SCSI revision: 02
Report Luns command not supported (support mandatory in SPC-3)
Scanning for device 1 0 6 0 ...
OLD: Host: scsi1 Channel: 00 Id: 06 Lun: 00
      Vendor: ESG-SHV  Model: SCA HSBP M18     Rev: 0.07
      Type:   Processor                        ANSI SCSI revision: 02
1 new device(s) found.               
1 device(s) removed.

On valide qu'un nouveau disque est disponible:

# scsiinfo -l
/dev/sdb /dev/sdc

On voit que ce n'est pas sda qui est revenu mais sdc qui vient d'arriver, c'est la conséquence des liens persistant fait par udev.

Maintenant, on partitionne /dev/sdc avec fdisk pour avoir les partitions qui vont bien :

# fdisk -l /dev/sdc

Disk /dev/sdc: 36.4 GB, 36420075008 bytes
255 heads, 63 sectors/track, 4427 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x6e1b40c8

   Device Boot      Start         End      Blocks   Id  System
/dev/sdc1               1         608     4883728+  fd  Linux raid autodetect
/dev/sdc2             609         851     1951897+  fd  Linux raid autodetect
/dev/sdc3             852        1094     1951897+  fd  Linux raid autodetect
/dev/sdc4            1095        4427    26772322+   5  Extended
/dev/sdc5            1095        4425    26756226   fd  Linux raid autodetect

Reconstruction du RAID soft

Prenons l'exemple de md1. Voici l'état du RAID avant maintenance :

# mdadm --detail /dev/md1
/dev/md1:
        Version : 00.90
  Creation Time : Mon Feb 23 19:28:00 2009
     Raid Level : raid1
     Array Size : 1951808 (1906.38 MiB 1998.65 MB)
  Used Dev Size : 1951808 (1906.38 MiB 1998.65 MB)
   Raid Devices : 2
  Total Devices : 2
Preferred Minor : 1
    Persistence : Superblock is persistent

    Update Time : Sun May  2 01:13:00 2010
          State : clean, degraded
 Active Devices : 1
Working Devices : 1
 Failed Devices : 1
  Spare Devices : 0

           UUID : e80a638f:b07bd9f4:feef8c2a:28641c05
         Events : 0.62

    Number   Major   Minor   RaidDevice State
       0       0        0        0      removed
       1       8       18        1      active sync   /dev/sdb2

       2       8        2        -      faulty spare
# cat /proc/mdstat 
Personalities : [raid1] 
...
md1 : active raid1 sda2[2](F) sdb2[1]
      1951808 blocks [2/1] [_U]
      
...

On va retirer le vieux sda2 et mettre sdc2 à la place :

# mdadm /dev/md1 -r failed -a /dev/sdc2
mdadm: hot removed 8:2
mdadm: added /dev/sdc2

L'important ici est d'utiliser le mot-clé “failed” pour retirer sda2. Si on spécifie directement la partition du disque cassé, mdadm refuse car /dev/sda n'existe plus (on n'a retiré le disque).

Si on regarde l'état du RAID soft tout de suite après avoir lancé la commande, on doit voir la progression de reconstruction du RAID1:

# cat /proc/mdstat 
Personalities : [raid1] 
...
md1 : active raid1 sdc2[2] sdb2[1]
      1951808 blocks [2/1] [_U]
      [==>..................]  recovery = 13.6% (267968/1951808) finish=0.4min speed=66992K/sec
...

Et à la fin, on retrouve la situation normale:

# cat /proc/mdstat 
Personalities : [raid1] 
...
md1 : active raid1 sdc2[0] sdb2[1]
      1951808 blocks [2/2] [UU]
      
...

Il reste donc à effectuer la même opération pour les autres RAID soft. On remarque, que la reconstruction se fait un RAID après l'autre:

# cat /proc/mdstat 
Personalities : [raid1] 
md3 : active raid1 sdc5[2] sdb5[1]
      26756160 blocks [2/1] [_U]
        resync=DELAYED
      
md2 : active raid1 sdc3[2] sdb3[1]
      1951808 blocks [2/1] [_U]
      [============>........]  recovery = 60.1% (1175232/1951808) finish=0.2min speed=61854K/sec
...
# cat /proc/mdstat 
Personalities : [raid1] 
md3 : active raid1 sdc5[2] sdb5[1]
      26756160 blocks [2/1] [_U]
      [=>...................]  recovery =  8.4% (2247936/26756160) finish=19.4min speed=20992K/sec
      
md2 : active raid1 sdc3[0] sdb3[1]
      1951808 blocks [2/2] [UU]
      
...

Réinstallation de GRUB

Comme on a changé le premier disque, le MBR ne contient plus l'install de GRUB. Il faut donc reinstaller GRUB dans le MBR :

# /usr/sbin/grub-install /dev/sdb
# /usr/sbin/grub-install /dev/sdc

Cette étape est indispensable pour le prochain reboot de la machine

Conclusion

Tout peut se faire sans rebooter, ce qui est l'un des buts du RAID1 moyennant d'utiliser des disques branchables-à-chaud. Le seul truc gênant reste le changement de nommage des disques, désormais le premier disque est sdc et le second sdb: que va-t-il se passer au prochain reboot ? Vous verrez bien…

Plus sérieusement, après un reboot, tout revient bien comme il faut : sdc redevient sda et le RAID1 suit :

# cat /proc/mdstat 
Personalities : [raid1] 
md3 : active raid1 sda5[0] sdb5[1]
      26756160 blocks [2/2] [UU]
      
md2 : active raid1 sda3[0] sdb3[1]
      1951808 blocks [2/2] [UU]
      
md1 : active (auto-read-only) raid1 sda2[0] sdb2[1]
      1951808 blocks [2/2] [UU]
      
md0 : active raid1 sda1[0] sdb1[1]
      4883648 blocks [2/2] [UU]
      
unused devices: <none>

On remarque que md1 est en “auto-read-only”. Ce n'est pas un problème, dès que le système voudra écrire dedans il passera en lecture/écriture.

Et voilà, le RAID1 a bien fait son travail et le changement de disqu s'est passé sans encombres.

Install de Debian depuis une clé USB

2010-09-09T21:51:49+00:00

ça ne marche pas encore

Outils nécessaires:

# aptitude install dosfstools syslinux mbr

Init de la clé:

# dd if=/dev/zero of=/dev/sdc bs=512 count=1

Partitionnement et formatage:

# fdisk /dev/sdc
n, p, 1, <ret>, <ret>, t, c, a, 1, w
# mkdosfs /dev/sdc1

Monter l'iso et la clé:

# mkdir /tmp/loop
# mount -o loop /path/to/netinstall.iso /tmp/loop
# mount /dev/sdc1 /mnt

Fichiers requis:

# cd /tmp/loop/install.i386
# cp initrd.gz vmlinuz /mnt
# cp /path/to/netinstall.iso /mnt
# sync

ajouter la conf de syslinux dans /mnt/syslinux.cfg:

default vmlinuz
append initrd=initrd.gz

Bootloader:

# syslinux /dev/sdc1
# install-mbr /dev/sdc

Démonter:

# cd
# umount /tmp/loop
# umount /mnt

Lancer l'installeur Debian par un boot PXE

2011-08-12T17:08:02+00:00

On peut installer Debian en bootant sur le réseau, pour celà, il faut:

Une machine qui puisse booter en PXE
Un serveur DHCP et PXE
Un serveur TFTP

En bref

Aller sur http://www.debian.org/distrib/netinst et choisir son architecture dans la liste de la rubrique “Network boot”
Aller dans le sous-répertoire netboot
Récupérer netboot.tar.gz
Extraire dans /tftpboot
Configurer le DHCP pour qu'il dise au client de charger pxelinux.0 (directive filename “pxelinux.0”)
Sous NetBSD, le service tftpd doit pouvoir être requêté plus de 40 par minute, en passant wait à wait:400 par exemple

Installer OpenVZ

2010-12-19T15:23:10+00:00

OpenVZ est une solution de virtualisation pour GNU/Linux basée sur des “conteneurs”. Il s'agit de “chroot” avec des fonctionnalité avancée : réseau, quotas disque/mémoire, possibilité d'avoir des distristributions différrentes, etc. Par contre, on ne peut avoir que GNU/Linux dans un conteneur, pour virtualiser d'autres systèmes, il faudra passer par d'autres solutions comme qemu, Xen ou KVM.

Cet article présente comment mettre en place OpenVZ sur Debian Squeeze.

Packages requis

Installer le noyau OpenVZ :

# aptitude install linux-headers-2.6-openvz-amd64 linux-image-2.6-openvz-amd64

Et les outils :

# aptitude install vzctl vzdump vzquota

Espace de stockage

Pas mal de choses vont être stockées dans /var/lib/vz, on va donc dédier une partition pour OpenVZ et la monter sur /var/lib/vz. En considérant qu'une telle partition soit disponible, voici la procédure à suivre :

Faire une sauvegarde du contenu de /var/lib/vz, en utilisant tar (et sont option -p qui permet de conserver les propriétaires et permissions des fichiers)
Supprimer le contenu de /var/lib/vz
Ajouter une entrée dans /etc/fstab pour la partition
Monter la partition dédiée sur /var/lib/vz
Mettre à jour les permissions et le propriétaire si nécessaire
Déballer le tar de sauvegarde

Voici un exemple utilisant un volume logique appelé openvz (volume group sys) :

# lvcreate -L 50G -n openvz sys
# mkfs.ext3 -m 0 /dev/sys/openvz
# cd /var/lib
# tar -cpzf ~/vz.tgz vz
# rm -rf vz/*
# mount /var/lib/vz 
# tar -xpzf ~/vz.tgz

Avec la ligne qui convient dans /etc/fstab :

/dev/mapper/sys-openvz  /var/lib/vz  ext3  defaults  0  2

Enfin, la plupart des documentations disponibles sur le net pour OpenVZ utilisent plutôt /vz que /var/lib/vz. Pour éviter les copier-coller hasardeux, on peut faire un lien symbolique :

# ln -s /var/lib/vz /vz

Configuration

Noyau

Il faut modifier la configuration du noyau pour certains paramètres réseau. On ajoute donc un fichier /etc/sysctl.d/openvz.conf avec les sysctl nécessaires à OpenVZ :

# On Hardware Node we generally need
# packet forwarding enabled and proxy arp disabled

net.ipv4.conf.default.forwarding=1
net.ipv4.conf.default.proxy_arp = 0
net.ipv4.ip_forward=1

# Enables source route verification
net.ipv4.conf.all.rp_filter = 1

# we do not want all our interfaces to send redirects
net.ipv4.conf.default.send_redirects = 1
net.ipv4.conf.all.send_redirects = 0

Pour activer les paramètres sans rebooter, il suffit d'exécuter :

# sysctl -p /etc/sysctl.d/openvz.conf

Réseau

Sous-réseau dédié

Par la suite, on utilisera un réseau privé dédié à nos machine openvz. Par exemple, choisissons le réseau 10.100.0.0/24, avec 10.100.0.1 comme adresse IP pour la machine physique. Il faut donc lui assigner cette IP :

# ifconfig venet0 inet 10.100.0.1

Pour garder cette configuration disponible après de futurs reboot, on ajoute une entrée dans /etc/network/interfaces :

auto eth0:0
iface eth0:0 inet static
	address 10.100.0.1
	netmask 255.255.255.255

<note>Si vous utilisez wicd, l'alias sera écrasé par les changements de connexions effectués par cet outils. Il faudra refaire la configuration à la main.</notes>

DNS

Pour faciliter la gestion des noms de machines, on installe dnsmasq qui va nous permettre de facilement fournir un service DNS aux machines. Il suffira d'ajouter la correspondance IP ↔ nom dans /etc/hosts ou un fichier de son choix par la suite.

Par la suite, on va placer tout les conteneurs dans un domaine DNS géré par notre dnsmasq, pour les besoins de l'article, on choisit un domain n'existant nul part ailleurs que la machine locale, par exemple : vz.lo.

On installe donc dnsmasq :
```
# aptitude install dnsmasq
```
On édite /etc/dnsmasq.conf pour indiquer que son domaine local est vz.lo :
```
local=/vz.lo/
```
On ajoute une entrée dans /etc/hosts pour la machine local dans le réseau OpenVZ :
```
10.100.0.1	hw.vz.lo
```
On modifie /etc/resolv.conf pour passer par dnsmasq en ajoutant cette 127.0.0.1 comme premier serveur de nom :
```
nameserver 127.0.0.1
```
Si on utilise du DCHP pour eth0, il faut modifier la configuration du client DHCP pour éviter un écrasement de notre configuration de /etc/resolv.conf. On édite donc /etc/dhcp/dhclient.conf pour décommenter :
```
prepend domain-name-servers 127.0.0.1;
```

Enfin, il faut redémarre le service dnsmasq à chaque modification de sa configuration ou de /etc/hosts :

# invoke-rc.d dnsmasq restart
Restarting DNS forwarder and DHCP server: dnsmasq.

Accès à Internet pour les VM

Utiliser un adressage réseau différent pour nos machines permet d'isoler les conteneurs du reste du réseau, ce qui est pratique pour ne pas gêner. Par contre, les conteneurs ne voient pas non plus le reste du réseau (seulement la machine physique) il faut donc ajouter une petit règle Netfilter pour leur permettre de joindre le reste du monde :

# iptables -t nat -A POSTROUTING -s 10.100.0.0/24 -o eth0 -j SNAT --to `ifconfig eth0 | awk '/inet addr:/ { print substr($2,6) }'`

Pour rendre cette configuration automatique, on peut modifier la configuration de l'interface réseau, dans /etc/network/interfaces :

allow-hotplug eth0
iface eth0 inet dhcp
	post-up iptables -t nat -A POSTROUTING -s 10.100.0.0/24 -o eth0 -j SNAT --to `ifconfig eth0 | awk '/inet addr:/	{ print	substr($2,6) }'`
	pre-down iptables -t nat -A POSTROUTING -s 10.100.0.0/24 -o eth0 -j SNAT --to `ifconfig eth0 | awk '/inet addr:/ { print substr($2,6) }'`

Configuration basique

organisation de la conf

Création d'un conteneur

Préparation

il faut debootstrap

# debootstrap --arch amd64 squeeze /var/lib/vz/private/101 http://localhost:9999/debian/

# vzctl set 101 --applyconfig basic --save
WARNING: /etc/vz/conf/101.conf not found: No such file or directory
Saved parameters for CT 101

on obtient un fichier /etc/vz/conf/101.conf

Ajouter

OSTEMPLATE=debian-6.0

Paramétrer le réseau :

# vzctl set 101 --ipadd 10.100.0.2 --save
# vzctl set 101 --nameserver 10.100.0.1 --save
# vzctl set 101 --hostname squeeze.vz.lo --save
# vzctl set 101 --searchdomain vz.lo --save

Ajouter une entrée DNS :

dans /etc/hosts :
```
10.100.0.2	squeeze.vz.lo
```
relancer dnsmasq :
```
# /etc/init.d/dnsmasq restart
```

Démarrer le conteneur :

# vzctl start 101
Starting container ...
Initializing quota ...
Container is mounted
Adding IP address(es): 10.100.0.1
Setting CPU units: 1000
Set hostname: squeeze.vz.lo
File resolv.conf was modified
Container start in progress...

Entrer dans le conteneur :

# vzctl enter 101
entered into CT 101
squeeze:/#

Un fois dans le conteneur, on peut le configurer.

Configuration

Ajouter les sources de paquets, /etc/apt/sources.list :

deb http://debian.ens-cachan.fr/ftp/debian squeeze main contrib
deb-src http://debian.ens-cachan.fr/ftp/debian/ squeeze main contrib

# Ces dépots seront disponibles lorsque squeeze sera stable
#deb http://security.debian.org/ squeeze/updates main contrib
#deb-src http://security.debian.org/ squeeze/updates main contrib

Mettre à jour :

# aptitude update
# aptitude safe-upgrade

Installer quelques paquets indispensables :

# aptitude install dnsutils build-essential openssh-client openssh-server less vim locales sudo

Configurer les locales, choisir les locales fr_FR :

# dpkg-reconfigure locales
Generating locales (this might take a while)...
  fr_FR.ISO-8859-1... done
  fr_FR.UTF-8... done
  fr_FR.ISO-8859-15@euro... done
Generation complete

Supprimer les terminaux physiques, éditer /etc/inittab :

#1:2345:respawn:/sbin/getty 38400 tty1
#2:23:respawn:/sbin/getty 38400 tty2
#3:23:respawn:/sbin/getty 38400 tty3
#4:23:respawn:/sbin/getty 38400 tty4
#5:23:respawn:/sbin/getty 38400 tty5
#6:23:respawn:/sbin/getty 38400 tty6

Configurer le fuseau horaire :

# dpkg-reconfigure tzdata

Transformer un conteneur en template

Au lieu de refaire l'étape debootstrap et configuration, on peut créer des templates qui serviront de base à la création d'autres conteneurs. Il s'agit de simples archives tar à placer dans /var/lib/vz/template/cache/.

Créer un template

Pour créer un template, on suit la procédure suivante :

Stopper le conteneur s'il est en cours d'exécution :
```
# vzctl stop 101
```

Supprimer les fichiers spécifiques à l'installation :

# cd /var/lib/vz/private/101
# rm etc/hostname etc/resolv.conf etc/ssh/ssh_host_*

Archiver le conteneur, attention au nommage qui doit refletter les paramètres de version et architecture utilisé lors du debootstrap :
```
# cd /var/lib/vz/private/101
# tar --numeric-owner -zcf /var/lib/vz/template/cache/debian-6.0-amd64-minimal.tar.gz .
```

Enfin, il faut vérifier que le répertoire /etc/vz/dists contient un fichier debian-6.0.conf. S'il n'existe pas, on copie le fichier debian.conf en debian-6.0.conf.

Utiliser un template pour créer un conteneur

Créer le conteneur :

# vzctl create 203 --ostemplate debian-6.0-amd64-minimal

Configurer le réseau :

Ajouter une entrée dans /etc/hosts et relancer dnsmasq

Utiliser vzctl pour configurer :

# vzctl set 203 --ipadd 10.100.0.5 --save
# vzctl set 203 --nameserver 10.100.0.1 --save
# vzctl set 203 --hostname andesi.vz.lo --save
# vzctl set 203 --searchdomain vz.lo --save

Démarrer le conteneur :

# vzctl start 203

Regénérer les clés du serveur SSH :

# vzctl exec 203 dpkg-reconfigure openssh-server

Customization

postcreate avec dpkg-reconfigure openssh-server
config ve-name.conf.sample

2011-07-29T15:13:48+00:00

Filesystem pour mettre une limite d'espace disque # mkfs.ext4 /dev/system/lxc-dns # tune2fs -i0 -c0 /dev/system/lxc-dns # mkdir /var/lib/lxc/dns # mount /dev/system/lxc-dns /var/lib/lxc/dns

Creation du conteneur

# SUITE=squeeze /usr/lib/lxc/templates/lxc-debian -p /var/lib/lxc/dns -n dns

Configuration

# vi /var/lib/lxc/dns/config

Fichier de conf, ajouter la configuration réseau à la fin:

# network
lxc.utsname = dns.orgrim.net
lxc.network.type = veth
lxc.network.flags = up
lxc.network.link = br0
lxc.network.hwaddr = DE:AD:BE:xx:xx:xx
lxc.network.ipv4 = 10.42.0.4/24
lxc.network.ipv6 = 2001:41d0:2:xxxx::4/64

Par défaut, le client DHCP est activé dans le conteneur, on peut le supprimer de cette façon, lxc se chargeant de mettre les IP fixes configurées :

echo -e "auto lo\niface lo inet loopback" > /var/lib/lxc/dns/rootfs/etc/network/interfaces

Démarrer le conteneur :

# lxc-start -n dns -d

Se connecter au conteneur :

# lxc-console -n dns

Le mot de passe par défaut est root, il faut le changer directement
Le conteneur se comporte alors comme une install normale

Debian: passage en testing

2010-09-09T22:18:47+00:00

Modifier /etc/apt/sources.list (y'a pas de volatile en testing)
MAJ des listes: apt-get update
MAJ de tools de packaging: aptitude install dpkg apt aptitude
MAJ du kernel et de la libc: aptitude install linux-image-2.6-686 libc6 libc6-i686 locales perl
On peut en profiter pour générer les locales: dpkg-reconfigure locales
Retirer les vieux kernels
Rebooter pour être bien sûr d'utiliser la nouvelle libc
MAJ du reste aptitude safe-upgrade autant de fois que nécessaire
aptitude autoclean
Rebooter

Que faire après l'installation

2010-05-04T17:25:06+00:00

Configuration des dépots apt

Mise à jours de sécurité

Dans le cas d'une installation aux CD/DVD:

Faire pointer sur le net
Mettre à jour

Dépots intéressants

Backports
Multimedia

Ajouter quelques packages sympa

OpenSSH

Le Secure Shell ou Console sécurisée, et un service réseau qui permet d'obtenir un accès distant an ligne de commande sur la machine. Les données sont cryptrées se qui permet d'éviter une écoute sur le réseau qui permettrait à une personne mal intentionnée de récupérer les mots de passe ou autres information.

# aptitude install openssh-server

Configuration de base de /etc/ssh/sshd_config :

Mettre le PermitRootLogin à no

De quoi compiler

Installer build-essential:

# aptitude install build-essential
Reading package lists... Done
Building dependency tree       
Reading state information... Done
Reading extended state information      
Initializing package states... Done
Reading task descriptions... Done  
The following NEW packages will be installed:
  binutils{a} build-essential bzip2{a} cpp{a} cpp-4.3{a} dpkg-dev{a} g++{a} 
  g++-4.3{a} gcc{a} gcc-4.3{a} libc6-dev{a} libgmp3c2{a} libgomp1{a} 
  libmpfr1ldbl{a} libstdc++6-4.3-dev{a} libtimedate-perl{a} linux-libc-dev{a} 
  make{a} 
0 packages upgraded, 18 newly installed, 0 to remove and 0 not upgraded.
Need to get 18.9MB of archives. After unpacking 60.7MB will be used.
Do you want to continue? [Y/n/?]

Un joli prompt

Gestion de Ruby sous Debian

2010-08-10T09:00:25+00:00

On va gérer les Gems à part, avec la dernière version de rubygems qui n'est pas à jour dans Lenny.

Installation de Ruby

Il nous faut Ruby, qu'on prend dans les dépots Debian:

# aptitude install ruby rdoc ri ruby-dev

Même si un package rubygems existe dans les dépots, on va utiliser les sources de rubygems:

Récupérer le tarball sur http://rubygems.org/pages/download
Extraire quelque part:

# tar xzf rubygems-1.3.7.tgz

Installer:

# cd rubygems-1.3.7
# ruby setup.rb

Il indique à la fin le chemin de la commande gem: /usr/bin/gem1.8

Suppression

Supprimer les packages:

# aptitude remove --purge ruby ruby1.8 rdoc rdoc1.8 ri ri1.8

Device iSCSI crypté sous GNU/Linux

2009-08-27T18:03:46+00:00

crypto, debian, linux, iscsi, reseau

On peut facilement configurer un device iSCSI crypté sur FreeBSD, voici l'équivalent sous Debian GNU/Linux.

Sur le serveur

Installer IET:

# aptitude install iscsitarget iscsitarget-modules-2.6-amd64

Dans /etc/ietd.conf:

Target iqn.2008-12.net.orgrim:storage.crypt.test
        Lun 0 Path=/home/iscsi/crypto.test,Type=fileio
        IncomingUser orgrim prout

Créer le fichier:

# mkdir /home/iscsi
# dd if=/dev/urandom of=/home/iscsi/crypto.test bs=1M count=1024

Relancer le daemon:

# /etc/init.d/iscsitarget restart

Sur le client

Installer le paquet contenant la partie initiator :

# aptitude install open-iscsi

Connection à la target

Il faut découvrir les targets fournies par le serveur, puis régler les paramètres d'authentification, et se logguer pour obtenir un device :

# iscsiadm -m discovery -t sendtargets -p 192.168.0.1
192.168.0.1:3260,1 iqn.2008-12.net.orgrim:storage.crypt.test
# iscsiadm -m node -T iqn.2008-12.net.orgrim:storage.crypt.test -p 192.168.0.1 -o update -n node.session.auth.authmethod -v CHAP
# iscsiadm -m node -T iqn.2008-12.net.orgrim:storage.crypt.test -p 192.168.0.1 -o update -n node.session.auth.username -v orgrim
# iscsiadm -m node -T iqn.2008-12.net.orgrim:storage.crypt.test -p 192.168.0.1 -o update -n node.session.auth.password -v prout
# iscsiadm -m node -T iqn.2008-12.net.orgrim:storage.crypt.test -p 192.168.0.1 -l
Logging in to [iface: default, target: iqn.2008-12.net.orgrim:storage.crypt.test, portal: 192.168.0.1,3260]
Login to [iface: default, target: iqn.2008-12.net.orgrim:storage.crypt.test, portal: 192.168.0.1,3260]: successful
# cat /proc/scsi/scsi
Attached devices:
Host: scsi3 Channel: 00 Id: 00 Lun: 00
  Vendor: IET      Model: VIRTUAL-DISK     Rev: 0
  Type:   Direct-Access                    ANSI  SCSI revision: 04

Partitionnement

On utilise fdisk comme toujours pour découvrir quel device correspond à notre LUN :

# fdisk -l
...
Disk /dev/sda: 1073 MB, 1073741824 bytes
34 heads, 61 sectors/track, 1011 cylinders
Units = cylinders of 2074 * 512 = 1061888 bytes
Disk identifier: 0x027ebc31

Disk /dev/sda doesn't contain a valid partition table

Ensuite, il faut partitionner:

# fdisk /dev/sda
n, p, 1, <return>, <return>, w

Encryption

On utilise cryptsetup disponible dans le paquet éponyme :

# cryptsetup -y -c aes-cbc-essiv:sha256 -s 256 -h sha256 luksFormat /dev/sda1

WARNING!
========
This will overwrite data on /dev/sda1 irrevocably.

Are you sure? (Type uppercase yes): YES
Enter LUKS passphrase:
Verify passphrase:
Command successful.

Il faut entrer une passphrase qui permettra de décrypter le device.

Formatage et montage

On “ouvre” le device :

# cryptsetup luksOpen /dev/sda1 crypt-iscsi
Enter LUKS passphrase:
key slot 0 unlocked.
Command successful.

Cette commande crée le device /dev/mapper/crypt-iscsi, qui correspond à la partition décryptée.

On termine par un système de fichier et le montage :

# mke2fs -j /dev/mapper/crypt-iscsi
# mkdir /mnt/iscsi
# mount /dev/mapper/crypt-iscsi /mnt/iscsi

Conclusion

Finalement, on voit que c'est plutôt équivalent. Ici, il y a plus de commandes à taper à cause de l'authentification pour l'initator. Mais on peut faciliter tout ça en configurant /etc/iscsi/iscsid.conf, voici un résumé :

node.startup = automatic
node.session.auth.authmethod = CHAP
node.session.auth.username = orgrim
node.session.auth.password = prout

Gérer les mails de plusieurs domaines avec Exim et PostgreSQL

2010-06-06T18:54:03+00:00

Cette doc n'est finie

Pour gérer plusieurs domains avec un serveur de mails, il faut passer par des comptes généralement appelés “virtuels” stockés dans une base de données (SQL, LDAP). L'utilisation d'une base permet d'être sûr qu'on ne mélange pas les comptes et les domaines. En effet, si on a un domaine a.fr et un domaine b.fr, un utilisateur bob sur le serveur de mail peut avoir deux adresses bob@a.fr et bob@b.fr. On va donc créer une base de donnée PostgreSQL et configurer Exim pour livrer les mails à partir de celle-ci.

Il existe de nombreuses documentations traitant du sujet sur le net. Par contre, il en existe peu qui utilisent Exim et PostgreSQL. On les a choisi dans cet article parce qu'Exim est le serveur de mail par défaut de Debian. Quant à PostgreSQL, il reste souvent dans l'ombre, alors qu'il a des fonctionnalités très intéressantes qui peuvent nous aider rendre la configuration d'Exim plus lisible (vues, procédures stockées, triggers…)

La configuration montrée ici est très fortement inspirée de celle décrite par Depesz dans sa suite d'articles sur Exim et PostgreSQL.

Installation

Pour installer PostgreSQL, on va suivre l'article dédié à ce sujet. On dédit une base nommée exim à un utilisateur exim :

# su - postgres
postgres$ createuser -DEIlPRS exim
Enter password for new role: 
Enter it again:
postgres$ createdb -E UTF8 -O exim exim

Pour installer exim, il faut choisir le paquet exim4-daemon-heavy qui contient les fonctionnalités qui nous intéressent, contrairement à exim4-daemon-light installé par défaut :

# aptitude install exim4-daemon-heavy

En choissant d'installer le paquet, les dépendances nécessaires à la connexion à PostgreSQL (la libpq) seront ajoutées, et exim4-daemon-light sera retiré.

Configuration d'Exim

Si Exim n'a jamais été configuré, debconf pose quelques questions, on peut faire les choix suivants sachant qu'on éditera le fichier de configuration à la main juste après :

Le type de configuration, on choisit une configuration locale, avec 127.0.0.1 comme adresse d'écoute.
Si on souhaite découper le fichier de configuration en petits morceaux, on choisit “Oui”. Ca sera plus pratique pour la suite.
Le format de mailbox Maildir.

On peut à tout moment revenir sur ses choix en reconfigurant le paquet exim4-config (dpkg-reconfigure exim4-config) ou en éditant /etc/exim4/update-exim4.conf.conf.

Sous Debian, la configuration d'Exim se fait dans /etc/exim4, le programme update-exim4.conf permet de générer le fichier de configuration qui sera utilisé par Exim. Le script de démarrage, le récrée au besoin lors du (re)démarrage du service. Le fichier de configuration effectif est /var/lib/exim4/config.autogenerated. Enfin, selon l'utilisation de la configuration découpée ou non, le fichier à éditer est soit /etc/exim4/exim4.conf.template, soit les fichiers présents dans /etc/exim4/conf.d et ses sous-répertoires.

Dans la configuration multi-domaines, on va modifier un certains nombres de fichiers pour utiliser la base de données. Le premier fichier à modifier est /etc/exim4/update-exim4.conf.conf, voici les paramètres les plus pertinents:

dc_eximconfig_configtype='internet'
dc_other_hostnames=''
dc_local_interfaces='192.168.0.1'
dc_use_split_config='true'
dc_localdelivery='maildir_home'

le paramètre dc_local_interfaces indique l'adresse IP sur laquelle les mails arriveront. On utilise la configuration découpée (dans /etc/exim4/conf.d) avec dc_use_split_config et le format de boîte Maildir.

Dans /etc/exim4/conf.d/, il y a un certains nombre de répertoires, contenant des fichiers préfixés par un numéro pour indiquer leur ordre dans la configuration. Lorsque update-exm4.conf crée le fichier final, il concatène les fichiers en parcurant les répertoires dans cet ordre : main, acl, router, transport, retry, rewrite et auth.

Connexion au serveur PostgreSQL

On part du principe qu'on peut se connecter au server PostgreSQL avec l'utilisateur exim depuis localhost et que PostgreSQL utilise le port TCP/5432 (le port par défaut). Ceci permet de facilement changer la configuration si on déplace le serveur PostgreSQL sur une autre machine.

Pour qu'Exim utilise notre base de données, on a ajoute la variable pgsql_servers dans /etc/exim4/conf.d/main/01_exim4-config_listmacrosdefs :

...
# debconf-driven macro definitions get inserted after this line
UPEX4CmacrosUPEX4C = 1

# PostgreSQL lookup configuration
hide pgsql_servers = 127.0.0.1::5432/exim/exim/motDePasseExim

# Create domain and host lists for relay control
# '@' refers to 'the name of the local host'
...

Le format de pgsql_servers est :

<hostname>::<port>/<database>/<user>/<password> : ...

On peut donner plusieurs serveurs et/ou bases de données en séparant les informations de connexion par ”:”, c'est pour cela que le port de connexion est séparé du nom d'hôte par ”::”.

Pour économiser des ressources, on peut utiliser la socket unix de PostgreSQL s'il est sur la même machine qu'Exim :

hide pgsql_servers = (/var/run/postgresql/.s.PGSQL.5432)/exim/exim/motDePasseExim

Pour finir, le paramètre pgsql_servers est préfixé du mot-clé “hide” qui permet de cache la valeur du paramètre aux utilisateurs non privilégiés qui peuvent tenter d'obtenir cette valeur avec /usr/sbin/exim4 -bP :

user$ /usr/sbin/exim4 -bP| grep pgsql
pgsql_servers = <value not displayable>

Domaines

La première chose à configurer est la liste des domaines que gère notre installation. On va bien sûr stocker cette liste dans la base de données. Pour cela, on ajoute une table “domains”:

exim=> CREATE TABLE domains (
    id SERIAL,
    domain TEXT NOT NULL DEFAULT '' UNIQUE,
    PRIMARY KEY (id)
);

Puis, on configure Exim pour qu'il aille cherche la liste des domaines dans PG, on modifie donc la variable domainlist local_domains, pour ajouter la recherche dans la base de données en plus de la configuration Debian. Dans le fichier /etc/exim4/conf.d/main/01_exim4-config_listmacrosdefs :

# List of domains considered local for exim. Domains not listed here
# need to be deliverable remotely.
domainlist local_domains = MAIN_LOCAL_DOMAINS : \
        @[ ] : \
        ${lookup pgsql {SELECT domain FROM domains WHERE domain = '${domain}' }}

Ensuite, on rédemarre Exim, et on fait quelques tests :

# invoke-rc.d exim4 restart
Stopping MTA for restart: exim4_listener.
Restarting MTA: exim4.

On essaye d'abord avec root@localhost, qui est redirigé vers l'utilisateur orgrim dans /etc/aliases:

# exim4 -bt root@localhost
R: system_aliases for root@localhost
R: system_aliases for orgrim@debian.home.orgrim.net
R: userforward for orgrim@debian.home.orgrim.net
R: procmail for orgrim@debian.home.orgrim.net
R: maildrop for orgrim@debian.home.orgrim.net
R: lowuid_aliases for orgrim@debian.home.orgrim.net (UID 1000)
R: local_user for orgrim@debian.home.orgrim.net
orgrim@debian.home.orgrim.net
    <-- root@localhost
  router = local_user, transport = maildir_home

On voit donc que les mails locaux sont bien pris en comptes par Exim. Maintenant, on essaye avec root@a.fr, le domaine qu'on souhaite gérer :

# exim4 -bt root@a.fr
R: dnslookup for root@a.fr
root@a.fr is undeliverable: Unrouteable address

Exim essaye de le transmettre vers le serveur de mail de a.fr, ce qui est normal vu que notre table des domaines est vide. Maintenant, on ajoute un domaine dans la base :

exim=> INSERT INTO domains (domain) VALUES ('a.fr');

Et on teste de nouveau :

# exim4 -bt root@a.fr
R: system_aliases for root@a.fr
R: system_aliases for orgrim@debian.home.orgrim.net
R: userforward for orgrim@debian.home.orgrim.net
R: procmail for orgrim@debian.home.orgrim.net
R: maildrop for orgrim@debian.home.orgrim.net
R: lowuid_aliases for orgrim@debian.home.orgrim.net (UID 1000)
R: local_user for orgrim@debian.home.orgrim.net
orgrim@debian.home.orgrim.net
    <-- root@a.fr
  router = local_user, transport = maildir_home

Voilà, Exim a bien trouvé le domaine dans notre base de donnée.

Comptes

Installer le module pgcrypto, qui servira à chiffrer le mot de passe et à l'authentification par le serveur IMAP (dovecot):

# aptitude install postgresql-contrib
# su - postgres
$ psql -d exim -f /usr/share/postgresql/8.3/contrib/pgcrypto.sql

Créer la table des comptes utilisateurs:

CREATE TABLE accounts (
    id SERIAL,
    username TEXT NOT NULL DEFAULT '',
    password TEXT NOT NULL DEFAULT '',
    fullname TEXT NOT NULL DEFAULT '',
    domain_id INTEGER NOT NULL DEFAULT 0 REFERENCES domains (id),
    PRIMARY KEY (id)
);

Ajouter un utilisateur en chiffrant son mot de passe en MD5-CRYPT:

INSERT INTO accounts (username, password, fullname, domain_id) VALUES ('orgrim', crypt('new password', gen_salt('md5')), 'Orgrim', (SELECT id FROM domains WHERE domain = 'orgrim.net'));

Vérification:

exim=> SELECT * FROM accounts;
 id | username |              password              | fullname | domain_id 
----+----------+------------------------------------+----------+-----------
  1 | orgrim   | $1$8gr9GqhM$7FAdtAkVBMzVzxboBZ5Jp1 | Orgrim   |         2

Routeur:

Transport:

User vmail

Process séparés pour livrer en temps que vmail: QUEUERUNNER='separate' dans /etc/default/exim4

Aliases

Table des aliases:

CREATE TABLE aliases (
    id SERIAL,
    domain_id INTEGER NOT NULL DEFAULT 0 REFERENCES domains (id),
    username TEXT NOT NULL DEFAULT '',
    destination TEXT NOT NULL DEFAULT '',
    PRIMARY KEY (id)
);

Tests:

exim=> INSERT INTO domains (domain) VALUES ('orgrim.net');
exim=> INSERT INTO aliases (domain_id, username, destination) SELECT id, 'nico', 'orgrim@orgrim.net' FROM domains WHERE domain = 'orgrim.net';
exim=> INSERT INTO aliases (domain_id, username, destination) SELECT id, 'nico', 'admin@orgrim.net' FROM domains WHERE domain = 'orgrim.net';
exim=> SELECT * from aliases;
 id | domain_id | username |    destination    
----+-----------+----------+-------------------
  1 |         2 | nico     | orgrim@orgrim.net
  2 |         2 | nico     | admin@orgrim.net
(2 rows)
exim=> SELECT destination FROM aliases JOIN domains ON domains.id = aliases.domain_id WHERE username = 'nico' AND domain = 'orgrim.net';
    destination    
-------------------
 orgrim@orgrim.net
 admin@orgrim.net

Config d'exim: ajout de /etc/exim4/conf.d/router/450_exim4-config_pgsql_aliases (attention au numéro, l'ordre des routers est important)

### router/450_exim4-config_pgsql_aliases
#################################

# This router handles aliasing declared in the DB
#

pgsql_aliases:
  debug_print = "R: pgsql_aliases for $local_part@$domain"
  driver = redirect
  allow_fail
  allow_defer
  data = ${lookup pgsql {SELECT destination FROM aliases JOIN domains ON domains.id = aliases.domain_id WHERE username = '${local_part}' AND domain = '${domain}'} }
  file_transport = address_file
  pipe_transport = address_pipe

Dans, cette configuration, orgrim est un compte local, admin n'existe pas:

# exim4 -bt nico@orgrim.net
R: system_aliases for nico@orgrim.net
R: pgsql_aliases for nico@orgrim.net
R: system_aliases for orgrim@orgrim.net
R: pgsql_aliases for orgrim@orgrim.net
R: userforward for orgrim@orgrim.net
R: procmail for orgrim@orgrim.net
R: maildrop for orgrim@orgrim.net
R: lowuid_aliases for orgrim@orgrim.net (UID 1000)
R: local_user for orgrim@orgrim.net
R: system_aliases for admin@orgrim.net
R: pgsql_aliases for admin@orgrim.net
admin@orgrim.net is undeliverable: Unrouteable address
    <-- nico@orgrim.net
orgrim@orgrim.net
    <-- nico@orgrim.net
  router = local_user, transport = maildir_home

Chiffrage des communications

Authentification

Exim:

begin authenticators
...
login:
driver = plaintext
public_name = LOGIN
server_prompts = "Username:: : Password::"
server_condition = ${lookup pgsql {SELECT verify_password('${quote_pgsql:$1}', '${quote_pgsql:$2}') }}
server_set_id = $1

PostgreSQL:

CREATE OR REPLACE FUNCTION verify_password(in_user TEXT, in_password TEXT) RETURNS INT4 AS $BODY$
DECLARE
    use_user TEXT;
    use_domain TEXT;
    tempint INTEGER;
BEGIN
    use_user := split_part(in_user, '@', 1);
    use_domain := split_part(in_user, '@', 2);
    SELECT a.id INTO tempint
    FROM accounts a JOIN domains d ON a.domain_id = d.id
    WHERE a.username = use_user AND d.domain = use_domain AND a.password = crypt(in_password, a.password);
    IF NOT FOUND THEN
       RETURN NULL;
    END IF;
    RETURN 1;
END;
$BODY$ LANGUAGE plpgsql;

Passage en production

DNS
Firewall
Tests pour de vrai

Scratchbox

2009-12-13T22:11:54+00:00

Installation de scratchbow dans un domU debian i386.

Installer Scratchbox

Installer une debian i386, ça passe dans Xen
Ajouter la source du dépot de scratchbox, dans /etc/apt/sources.list:

deb http://scratchbox.org/debian/ apophis-r4 main

Installer les packages suivants:

sudo aptitude install scratchbox-core scratchbox-libs scratchbox-devkit-cputransp \
 scratchbox-devkit-debian scratchbox-devkit-maemo3 scratchbox-devkit-perl \
 scratchbox-toolchain-cs2005q3.2-glibc2.5-arm scratchbox-toolchain-cs2005q3.2-glibc2.5-i386 \
 scratchbox-toolchain-host-gcc

Ajouter ce paramètre à /etc/sysctl.conf:

vm.vdso_enabled = 0

# echo 0 > /proc/sys/vm/vdso_enabled

Ajouter son user dans scratchbox:

# sb-adduser orgrim

Maemo SDK

Récupérer et lancer le script d'install automatique de maemo:

$ cd ~
$ wget http://repository.maemo.org/stable/4.1.2/maemo-sdk-install_4.1.2.sh
$ chmod +x maemo-sdk-install_4.1.2.sh
$ ./maemo-sdk-install_4.1.2.sh

Ajouter les binaires fermés si on le souhaite:

$ /scratchbox/login
[sbox-: ~] > sb-conf select DIABLO_ARMEL
[sbox-DIABLO_ARMEL: ~] > fakeroot apt-get install maemo-explicit
[sbox-DIABLO_ARMEL: ~] > sc-conf select DIABLO_X86
[sbox-DIABLO_X86: ~] > fakeroot apt-get install maemo-explicit

Lancer l'environnement sous X

Se logguer dans le domU en activant le X11Forwarding:

$ ssh -X scratchbox

Installer Xephyr, un Xnest amélioré :

$ sudo aptitude install xserver-xephyr

Lancer Xephyr:

$ Xephyr :1 -host-cursor -screen 800x480x16 -dpi 96 -ac -extension Composite &

Dans scratchbox, lancer l'environnement graphique:

$ /scratchbox/login
[sbox-DIABLO_X86: ~] > export DISPLAY=:1  
[sbox-DIABLO_X86: ~] > af-sb-init.sh start

Ajouter le dépot maemo extras

Ajouter un fichier maemo-extras.list dans /etc/apt/sources.list.d de scratchbox :

deb http://repository.maemo.org/extras/ diablo free non-free
deb-src http://repository.maemo.org/extras/ diablo free non-free

Un petit test:

[sbox-DIABLO_X86: ~] > fakeroot apt-get update
...
[sbox-DIABLO_X86: ~] > fakeroot apt-cache search flac
flac - Free Lossless Audio Codec - command line tools
libflac8 - Free Lossless Audio Codec - runtime C library
libflac-dev - Free Lossless Audio Codec - C development library
libflac++6 - Free Lossless Audio Codec - C++ runtime library
libflac++-dev - Free Lossless Audio Codec - C++ development library
timidity - Software sound renderer (MIDI sequencer, MOD player)
lightmediascanner0-flac - Lightweight library to scan media.
libflac-doc - Free Lossless Audio Codec - library documentation
python2.5-mutagen - audio metadata editing library

Faire la même chose pour chaque target

Mémo d'installation de Debian

2009-08-27T21:43:32+00:00

Voir aussi la formation Debian GNU/Linux 5.0.

Netinstall

Principales étapes

Récupérer une ISO de Debian netinstall et graver
Booter dessus
Installer avec un partitionnement de base, On prend le partitionnement manuel, 10 Go pour /, 2x la RAM comme SWAP, et le reste pour /home
On choisit un miroir proche de la maison pour les packages
Dans tasksel, le seul groupe intéressant pour le moment est laptop

Un encart sur tasksel

tasksel est un programme Debian qui permet d'installer des groupes de paquets directement. On peut l'utiliser à tout moment, il a même sa page de man.

Pour avoir la liste des groupes :

# tasksel --list-tasks
u desktop       Desktop environment
i web-server    Web server
u print-server  Print server
u dns-server    DNS server
u file-server   File server
i mail-server   Mail server
i database-server       SQL database
u laptop        Laptop
u manual        manual package selection

Pour connaître les nom des paquets composant le groupe :

# tasksel --task-packages laptop
acpi-support
hibernate
acpi
powertop
apmd
radeontool
anacron
wireless-tools
cpufrequtils
nvclock
wpasupplicant
vbetool
acpid
pcmciautils
toshset
bluetooth
avahi-autoipd

Le seul problème de tasksel réside dans son exécution lors de l'installation depuis le CD. On ne sait pas trop ce qu'il va installer. Mais bon on voit ici que les choix du groupe laptop sont plutôt judicieux.

Après l'installation

Passage en testing

On met un source.list qui va bien:

# cat /etc/apt/sources.list
deb ftp://ftp.proxad.net/mirrors/ftp.debian.org/ testing main contrib
deb-src ftp://ftp.proxad.net/mirrors/ftp.debian.org/ testing main contrib

deb http://security.debian.org/ testing/updates main contrib
deb-src http://security.debian.org/ testing/updates main contrib

Puis on met à jour :

# aptitude update
# aptitude dist-upgrade
# aptitude update
# aptitude full-upgrade

Installation de KDE

# aptitude install kde kde-i18n-fr

On reboote sur le nouveau noyau installé lors du passage en testing, et tout marche !!

Configuration du son

# aptitude install alsa
# alsaconf
# alsamixer

Installation de programmes utiles

Navigateur: iceweasel iceweasel-l10n-fr
Son et vidéo: amarok mplayer libdvdread libdvdnav
Editeur: emacs vim
Images: gqview gimp
Autres packages: libdvdcss sur VideoLAN.org, prendre le package Debian et l'installer avec dpkg -i. w32codecs sur le site de mplayer, déballer le tar, arranger les droits et le mettre dans /usr/lib/win32.

Il reste la récupération de configuration pour GPG, SSH…

OpenWRT customisé avec l'image builder

2011-01-17T20:05:56+00:00

http://wiki.openwrt.org/doc/howto/imagebuilder

Créer un profil

Pour le linksys wrt54gl, on utilise l'architecture brcm47xx. Ajouter un fichier 666-Brouette.mk dans target/linux/brcm47xx/profiles :

define Profile/Brouette
  NAME:=Brouette custom
  PACKAGES:=-dnsmasq -ppp -ppp-mod-pppoe bridge hostapd-mini kmod-b43 kmod-crypto-aes kmod-crypto-core kmod-crypto-arc4 kmod-cfg80211 kmod-mac80211 ntpdate
endef

define Profile/Brouette/Description
	Package set and config for brouette
endef
$(eval $(call Profile,Brouette))

Pour vérifier, un make info à la racine de l'image builder donne ceci :

$ make info
Current Target: "brcm47xx"
Default Packages: base-files libc libgcc busybox dropbear mtd uci opkg udevtrigger hotplug2 dnsmasq iptables ppp ppp-mod-pppoe kmod-ipt-nathelper firewall wpad-mini kmod-switch kmod-diag nvram
Available Profiles:

Broadcom-b43:
	Broadcom BCM43xx WiFi (default)
	Packages: kmod-b43 kmod-b43legacy
[...]
Brouette:
	Brouette custom
	Packages: -dnsmasq -ppp -ppp-mod-pppoe bridge hostapd-mini kmod-b43 kmod-crypto-aes kmod-crypto-core kmod-crypto-arc4 kmod-cfg80211 kmod-mac80211 ntpdate
[...]

Ajouter des fichiers de configurations

On crée un répertoire contenant l’arborescence des fichiers custom :

$ mkdir -p brouette/etc/config
$ mkdir -p brouette/etc/dropbear

On peut ajouter sa clé SSH dans brouette/etc/dropbear/authorized_keys et recopier les fichiers de etc/config déjà présents dans une install, il suffit de regarder dans le répertoire /jffs pour voir les fichiers modifiés.

OpenWRT sur un Linksys WRT54GL

2009-08-27T18:04:17+00:00

linux, openwrt, wifi, reseau

Mettre à jour

Voici une petite doc sur un classique : comment flasher le WRT54GL pour y mettre OpenWRT. En fait, c'est pas évident au premier abord, surtout qu'il n'y a pas beaucoup de documentation francophone.

Récupérer une image

Comment bien choisir son image d'OpenWRT, en fait après avoir pas mal tourné en rond dans le wiki, (qui n'est pas forcément à jour par rapport au système, mais ça viendra) les images qui vont bien sont :

Pour White Russian, la version précédente : .../whiterussian/.../openwrt-wrt54g-squashfs.bin
Pour Kamikaze, la version actuelle stable 7.09 : .../kamikaze/.../openwrt-wrt54g-2.4-squashfs.bin
Pour Kamikaze, la dernière version 8.09_RC1 : .../kamikaze/.../openwrt-wrt54g-squashfs.bin

Attention à bien vérifier l'intégrité de l'image téléchargée via MD5.

Avant la version 8.09_RC1, il n'y a pas de driver libre pour le wifi dans le noyau 2.6.

Flasher le routeur depuis l'interface web Linksys

La première chose à faire est de se connecter à l'interface web de gestion du routeur, il faut une adresse IP dans la plage 192.168.1.0/24, l'adresse du routeur étant 192.168.1.1 par défaut, par exemple :

# ifconfig eth1:1 inet 192.168.1.2 up

Pour installer une image, la première fois :

Il faut connecter le cable sur un port ethernet de 1 à 4 sur le routeur.
Aller sur http://192.168.1.1, on ne met pas de user, et “admin” comme mot de passe. Puis dans Administration > Firmware upgrade.
Choisir l'image à uploader dans le routeur et faire upgrade. Le routeur se flashe et reboot tout seul, il faut attendre un peu et tenter la connection telnet ou web sur 192.168.1.1

Flasher le routeur par TFTP

Il faut d'abord installer un client TFTP, comme “atftp” :

# aptitude install atftp

Ensuite, il faut vérifier que le boot_wait est activé. Ce paramètre indique au routeur d'attendre de recevoir des réquêtes TFTP au boot, ce qui permet de pouvoir le flasher :

routeur# nvram show | grep boot_wait
size: 2475 bytes (30293 left)
boot_wait=on

Sinon, il faut l'activer, mais pour moi c'était déjà fait :

routeur# nvram set boot_wait=on
routeur# nvram commit &amp;&amp; reboot

Normalement, avec Kamikaze, on n'a pas besoin de trafiquer le nvram pour configurer le routeur.

Pour flasher le routeur :

Débrancher l'alimentation du routeur
Lancer la commande suivante :

atftp --trace --option "timeout 1" --option "mode octet" --put --local-file openwrt-wrt54g-squashfs.bin 192.168.1.1

Brancher l'alimentation, le transfert TFTP doit commencer presque immédiatement
A la fin, le routeur reboote tout seul, lorsqu'il est de nouveau disponible, c'est prêt.

Configuration basique

Le plus simple est d'aller sur l'interface graphique (http://192.168.1.1), la première fois il est demandé de mettre un mot de passe root. On peut ensuite se connecter en SSH, sinon c'est telnet. L'interface graphique permet de tout configurer, ça permet d'avoir quelque chose de fonctionnel très vite, les paramètres par défaut sont corrects.

Nettoyer la nvram

D'abord, il faut mettre un mot de passe root costaud et utiliser SSH.

Ensuite, on peut lancer les commandes suivantes pour nettoyer la nvram, quand le routeur est connecté au Net :

cd /tmp
wget http://downloads.openwrt.org/people/kaloz/nvram-clean.sh
chmod a+x nvram-clean.sh
./nvram-clean.sh
nvram commit
rm nvram-clean.sh

Le script de nettoyage m'a donné ça à la fin :

Before: size: 9603 bytes (23165 left)
After: size: 2475 bytes (30293 left)

C'est toujours ça de gagné

Conclusion

L'opération est somme toute assez simple quand on a bien compris le principe et qu'on ne panique pas. Il est aussi important de récupérer la bonne image pour ne pas rendre le routeur inutile (quoiqu'il est beau avec ses antennes, mais de là à le transformer en objet décoratif…)

Le seul soucis de WRT54GL vient de l'espace disque disponible, surtout que les fichiers de configuration sont bien organisés. Refaire une image vraiment minimale devient vite nécessaire, pour s'amuser à réduire la taille du système au maximum.

OpenWRT

2009-04-13T19:33:43+00:00

Docs importantes

Hardware/Linksys/WRT54GL – La page du routeur
Faq
NetworkInterfaces – VLAN et bridge
DemilitarizedZoneHowto – Howto pour faire une DMZ

Réseau

Comprendre le fonctionnement et la configuration des VLAN
Voir si la configuration du réseau de la maison est possible:
- Machine en DMZ avec VM utilisant des VLAN taggués pour se retrouver dans le bon réseau
- Redirection en tout genre (Squid, SquidGuard, Bittorent, QoS) pour faire un AP public

/etc/config/network:

config 'switch' 'eth0'
        option 'vlan0' '0 1 2 3 5*'
        option 'vlan1' '4 5'

config 'interface' 'loopback'
        option 'ifname' 'lo'
        option 'proto' 'static'
        option 'ipaddr' '127.0.0.1'
        option 'netmask' '255.0.0.0'

config 'interface' 'lan'
        option 'type' 'bridge'
        option 'ifname' 'eth0.0'
        option 'proto' 'static'
        option 'netmask' '255.255.255.0'
        option 'ipaddr' '192.168.0.2'

config 'interface' 'wan'
        option 'ifname' 'eth0.1'
        option 'proto' 'dhcp'

/etc/config/firewall:

config defaults
        option syn_flood        1
        option input            ACCEPT
        option output           ACCEPT
        option forward          REJECT

config zone
        option name             lan
        option input    ACCEPT
        option output   ACCEPT
        option forward  REJECT

config zone
        option name             wan
        option input    REJECT
        option output   ACCEPT
        option forward  REJECT
        option masq             1

config forwarding
        option src      lan
        option dest     wan

Interfaces:

# ifconfig -a
br-lan    Link encap:Ethernet  HWaddr 00:21:29:B5:D7:6D
          inet addr:192.168.0.2  Bcast:192.168.0.255  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:403677 errors:0 dropped:0 overruns:0 frame:0
          TX packets:517281 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:47834661 (45.6 MiB)  TX bytes:659379999 (628.8 MiB)

eth0      Link encap:Ethernet  HWaddr 00:21:29:B5:D7:6D
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:925435 errors:0 dropped:0 overruns:0 frame:0
          TX packets:918958 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:717651833 (684.4 MiB)  TX bytes:719172944 (685.8 MiB)
          Interrupt:4

eth0.0    Link encap:Ethernet  HWaddr 00:21:29:B5:D7:6D
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:404231 errors:0 dropped:0 overruns:0 frame:0
          TX packets:517340 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:49491778 (47.1 MiB)  TX bytes:661147896 (630.5 MiB)

eth0.1    Link encap:Ethernet  HWaddr 00:21:29:B5:D7:6D
          inet addr:88.186.16.24  Bcast:88.186.16.255  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:521209 errors:0 dropped:0 overruns:0 frame:0
          TX packets:401138 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:651502601 (621.3 MiB)  TX bytes:54119672 (51.6 MiB)

lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:27 errors:0 dropped:0 overruns:0 frame:0
          TX packets:27 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:2243 (2.1 KiB)  TX bytes:2243 (2.1 KiB)

wl0       Link encap:Ethernet  HWaddr 00:21:29:B5:D7:6F
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:260 errors:3 dropped:0 overruns:0 frame:2581568
          TX packets:3519 errors:4 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:23206 (22.6 KiB)  TX bytes:766688 (748.7 KiB)
          Interrupt:2 Base address:0x5000

IPv6 Freebox sur le LAN

Installer de quoi avoir de l'IPv6: kmod-ipv6, ip, radvd
Vérifier qu'on peut pinger un host en IPv6: ping6 www.kame.net
Trouver le subnet IPv6 de la Freebox (trouver la terminologie: subnet/IPv6 ??)
Configurer radvd
Configurer les clients sur le LAN

PC portable entièrement crypté avec boot sur clé USB

2009-08-27T17:46:40+00:00

crypto, debian, linux

De plus en plus de distribution Linux proposent d'installer le système sur des partitions cryptées, c'est le cas de Debian et Fedora.

Dans ce genre d'installation, tout n'est pas crypté, il y a forcément une partition ”/boot” qui contient grub, le kernel et l'initrd, qui ne peuvent être cryptés. En effet le BIOS doit pouvoir lire grub pour le charger et grub doit pouvoir lire le kernel et l'initrd, à ce moment du boot, le système n'a pas les éléments nécessaires pour décrypter un espace disque et y lire ces programmes.

La solution pour avoir le disque dur totalement crypté est de mettre la partition /boot ailleurs, sur une clé USB par exemple. On va donc transférer une Debian sur un espace crypté en LVM et passer le kernel et grub sur une clé USB.

Les noms des devices sont à adapter selon le contexte.

Préparation

Il y a quelques prérequis pour cette opération :

Pour le backup: une autre machine, un disque dur USB,
Pour la configuration: un live CD ou SystemRescueCD sur un clé USB,
Pour le boot: une clé USB. Le BIOS du portable doit pouvoir booter sur une clé USB.

Ensuite, il faut installer tous les packages nécessaires:

# aptitude install lvm2 initramfs-tools cryptsetup hashalot mbr

Sauvegarde du système

Tout d'abord, il faut booter le portable sur SystemRescueCD ou un LiveCD qui possède de quoi faire un tar, scp, cryptsetup, du LVM.

Ensuite, on monte les partitions du système à sauvegarder. Cette techinque est à retenir, car on manipule les fichiers du système à froid, on est donc sûr que le système ne changera pas durant le backup:

Pour trouver quel est le disque dur du portable:

# fdisk -l
--> /dev/sda

On crée un répertoire pour monter la partition root du système à sauvegarder et on monte les partitions (à adapter à son /etc/fstab) :

# mkdir /a
# mount /dev/sda1 /a
# mount /dev/sda3 /a/home

Enfin, on sauvegarde ailleurs, sur une autre machine, par SSH, et on démonte les partitions :

# cd /a
# tar cpf - * | ssh orgrim@192.168.0.1 "cat | gzip > laptop.tar.gz"
# cd /
# umount /a/home
# umount /a

La commande crée le tar sur la sortie standard, renvoyée dans ssh, qui se connecte. On demande à SSH d'exécuter la commande entre guillemets au lieu de lancer un shell. Pour capter le flux du tar, on lance cat, qu'on redirige dans gzip puis dans un fichier.

On utilise tar pour ne pas altérer les fichiers, avec l'option “p” qui conserve les permissions et propriétaires des fichiers/répertoires.

Crypter le disque dur

Partionnement

On va partitionner le disque dur pour avoir une partition de SWAP (de 1Go, soit 2 fois la RAM, à adapter) et une partition pour un volume physique LVM2, voici pour référence les commandes à effectuer avec fdisk :

# fdisk /dev/sda
o, n, p, 1, <return>, +1024M, t, 1, 82
n, p, 2, <return>, <return>, t, 2, 8e

Destruction et initialisation des données du disques

Pour que ça serve à quelque chose, il ne faut pas laisser de trace des données qui sont actuellement sur le disque dur. Il existe des outils dit de “forensic” comme TCT, qui peuvent retrouver des données effacées.

Pour que l'encryption soit efficace sur le disque dur, il faut générer du bruit partout.on va donc prendre du bruit de /dev/urandom (parce /dev/random, c'est bien trop long) :

# dd if=/dev/urandom of=/dev/sda1
# dd if=/dev/urandom of=/dev/sda2

Cette opération est très longue, pour 80 Go ça m'a pris 12 heures environ.

Configuration du LVM crypté

La première chose à faire est de créer un partion LUKS (Linux Unified Key Setup). Ca permet de stocker les clés et la configuration du cryptage au début de la partition, comme ça n'importe quel système GNU/Linux est sensé pouvoir le lire. On fait ça avec cryptsetup, qui demande une passphrase à la création (luksFormat) et déverouille lors de l'ouverture de la partition (liksOpen).

# cryptsetup -y --cipher aes-cbc-essiv:sha256 --key-size 256 luksFormat /dev/sda2
# cryptsetup luksOpen /dev/sda2 cryptpart

Le “luksOpen” a créé un mapping pour la partition cryptée, on n'utilise donc plus ”/dev/sda2” mais ”/dev/mapper/cryptpart”.

On crée ensuite notre configuration LVM2 :

Volume Physique :

# pvcreate /dev/mapper/cryptpart

Volume Group :

# vgcreate system /dev/mapper/cryptpart

Volumes Logiques :

# lvcreate -n root -L 10G system
# pvdisplay /dev/mapper/cryptpart | grep Free
  Free PE               16273
# lvcreate -n home -l 16273 system

Pour “lvcreate”, on utilise une taille fixe pour ”/” (”-L 10G”) et le reste pour ”/home”, en spécifiant le nombre exact de “Physical Extends” restants sur le volume physique.

Enfin, les systèmes de fichiers en ext3 :

# mke2fs -j /dev/mapper/system-root
# mke2fs -j -m 0 /dev/mapper/system-home

Restauration du système backupé

On procède maintenant à l'opération inverse :

# mount /dev/mapper/system-root /a
# mkdir /a/home
# mount /dev/mapper/system-home /a/home
# cd /a
# ssh orgrim@192.168.0.1 "zcat laptop.tar.gz" | tar xpf -

Tout est désormais en place sur un disque dur crypté.

Modification de la configuration du système

Il faut modifier quelques fichiers de configuration pour que le système puisse booter sur le LVM crypté:

/etc/crypttab, déclaration de la partition root crypté pour le device mapper :

# <target name> <source device>         <key file>      <options>
cryptpart       /dev/hda2       none    verify,cipher=aes,hash=sha256

/etc/fstab, passage vers LVM2 :

  # /etc/fstab: static file system information.
  #
  # <file system> <mount point>   <type>  <options>       <dump>  <pass>

  proc            /proc           proc    defaults        0       0
  /dev/mapper/system-root       /               ext3    defaults,errors=remount-ro 0       1
  /dev/sda1       /boot   ext2    defaults,noauto 0 2
  /dev/mapper/system-home       /home           ext3    defaults        0       2
  /dev/mapper/swap       none            swap    sw              0       0
  /dev/hdc        /media/cdrom0   udf,iso9660 user,noauto     0       0

/dev/sda1 sera le device de la clé USB sur le système définitif, l'option “noauto” permet de ne pas monter automatiquement cette partition, on évite ainsi une erreur si la clé utilise un autre device.

Créer la clé USB pour le boot

Prépartion de la clé

Il faut insérer la clé USB et trouver son device avec fdisk -l puis l'initialiser :

# fidsk /dev/sdd
o, n, p, 1, <return>, <return>, a, 1

On formatte en ext2 :

# mk2efs /dev/sdd1

Chroot sur le système restauré

Pour cette opération, on va se “chrooter” sur le système crypté :

# mount -o bind /dev /a/dev
# mount -t sysfs none /a/sys
# mount -t proc none /a/proc
# mkdir /a/usbkey
# mount /dev/sdd1 /a/usbkey
# chroot /a /bin/bash

On est maintenant sur notre Debian hébergée sur le disque dur du portable.

Mise à jour de l'initrd

Maintenant qu'on est chrooté, on a accès à “initramfs-tools”. On recrée donc un nouvel initrd, qui aura automagiquement tout ce qu'il faut pour gérer le disque crypté :

# update-initramfs -v -t -c -k 2.6.26-1-686
update-initramfs: Generating /boot/initrd.img-2.6.26-1-686
...
Calling hook cryptroot
...

On peut remplacer ”-k <version du noyau>” par ”-k all” qui recréera tout les initrd nécessaires. Il faut bien voir “update-initramfs” ajouter les outils nécessaires à la gestion du disque encrypté, sinon le système ne pourra pas booter.

Pour vérifier, on peut extraire le contenu de l'initrd, il doit y avoir un fichier conf/conf.d/cryptroot, qui reprend les informations de /etc/crypttab :

# cd /tmp
# mkdir test
# cd test
# zcat /boot/initrd.img-2.6.26-1-686 | cpio -i
# cat conf/conf.d/cryptroot
target=cryptpart,source=/dev/hda2,key=none,lvm=system-root,cipher=aes,hash=sha256
# cd /
# rm -rf /tmp/test

Grub sur la clé USB

Il faut mettre à jour le fichier de configuration de Grub (/boot/grub/menu.lst). On va mettre à jour la configuration utilisée par debconf pour la mise à jour de du fichier lors d'une installation de noyau, ça servira pour l'installation de futur noyau :

# kopt=root=/dev/mapper/system-root ro
# groot=(hd0,0)

Avec le “root” pour les 2 entrées de boot, on met le premier device car le BIOS oriente le nommage des devices selon l'ordre de boot (donc hd0 sera la clé) :

title           Debian GNU/Linux, kernel 2.6.26-1-686
root            (hd0,0)
kernel          /vmlinuz-2.6.26-1-686 root=/dev/mapper/system-root ro
initrd          /initrd.img-2.6.26-1-686

Ensuite, on doit copier le contenu du répertoire /boot sur la clé, c'est à dire l'installation existante de Grub, le kernel et l'initrd :

# cp -R /boot/* /usbkey

Puis on passe sur la clé :

# umount /usbkey
# mount /dev/sdd1 /boot

Et on mets à jour l'installation de Grub :

# grub-install --recheck --no-floppy /dev/sdd
...
(hd2) /dev/sdd
...

grub-install donne le mapping des disques entre le noyau et son nommage, dans notre exemple, il faudra utiliser (hd2) pour l'installation de Grub

Enfin, on peut installer Grub sur le MBR de la clé :

# grub
grub> root (hd2,0)
 Filesystem type is ext2fs, partition type 0x83
grub> setup (hd2)
Checking if "/boot/grub/stage1" exists... no
 Checking if "/grub/stage1" exists... yes
 Checking if "/grub/stage2" exists... yes
 Checking if "/grub/e2fs_stage1_5" exists... yes
 Running "embed /grub/e2fs_stage1_5 (hd2)"...  17 sectors are embedded.
succeeded
 Running "install /grub/stage1 (hd2) (hd2)1+17 p (hd2,0)/grub/stage2 /grub/menu.lst"... succeeded
Done.

grub> quit

Réinitialiser le MBR du disque

Pour faire les chose proprement, il est sympa de supprimer le Grub déjà installé dans le MBR du disque, ainsi la machine apparaitra vierge pour le profane si la clé USB de boot n'est pas en place :

# install-mbr /dev/sda

Sortie du chroot

Pour sortir du chroot :

# sync
# umount /boot
# exit
# umount /a/dev /a/sys /a/proc /a

Voilà, il reste maintenant à booter le système sur la clé…

Démarrage sur la clé USB

On reboote et on essaye de booter sur la clé. Le menu de Grub doit apparaitre, quand on choisit une entrée, le kernel doit être lancé. Les problèmes ici peuvent venir d'une mauvaise configuration utilisant les mauvais de devices, il faut donc bien connaitre son matériel pour bien interpréter la sortie de fdisk -l.

Lors du boot, l'initrd doit demander la passphrase pour décrypter le volume physique.

Une fois la machine booté, on peut débrancher sans risques la clé USB du portable.

Configurer la swap

Une fois qu'on are booté sur le système crypté avec la clé, il reste à faire la swap.

On crée une clé pour la swap qui sera stockée dans le fichier /etc/keys/swapkey, voici une commande pour créer une clé aléatoire :

# dd if=/dev/random bs=5k count=1 2> /dev/null | hashalot -s 'Une bonne phrase de sel bien compliquée' -x sha256 > /etc/keys/swapkey
# chmod 600 /etc/keys/swapkey

Puis on crypte la partition dédiée à la swap :

# cryptsetup create swap /dev/hda1 -d /etc/keys/swapkey -c aes-cbc-essiv:sha256 -h sha256

On ajoute une entrée dans /etc/crypttab :

# cat /etc/crypttab
swap /dev/hda1 /etc/keys/swapkey cipher=aes,hash=sha256

Puis on crée effectivement la swap :

# mkswap /dev/mapper/swap

Enfin, on l'active :

# swapon /dev/mapper/swap

Backup de la clé USB

Il est conseillé de faire un backup de la clé USB sur une autre machine, au cas où on la perd… Un petit tar c'est vite fait.

En cas de problème

Si on oublie la passphrase, c'est MORT. On peut donc recommencer à l'étape du “luksFormat”.
Si on veut reprendre sur SystemRescueCD, pour monter la racine :

# cryptsetup luksOpen /dev/sda2 cryptpart
# vgscan
# vgchange -ay
# mkdir /a
# mount /dev/mapper/system-root /a

Serveur de boot sous Debian pour machines diskless PowerPC

2009-08-27T21:35:48+00:00

Le problème des machines PowerPC, c'est que le boot en réseau se fait par BOOTP au lieu de PXE (pour les machines x86). Il fallait donc un serveur BOOTP sur le réseau. Il n'y a pas de serveur BOOTP sur GNU/Linux, c'est le serveur DHCP de ISC qui fournit cette fonctionnalité. Mais que fait-on lorsqu'un serveur DHCP est déjà présent sur le réseau pour fournir les adresses de centaines de stations ?

Réponse: On configure le serveur DHCP pour qu'il ne fasse que du BOOTP.

Installation

Sous Debian:

# aptitude install dhcp3-server

Configuration

Le principe :

Créer un serveur DHCP “non autoritaire”.
N'assigner des adresses IP qu'aux machines dont on connait l'adresse MAC via BOOTP.

Un serveur non autoritaire permet de ne pas gêner un autre serveur DHCP sur le réseau lorsque le serveur refuse d'assigner une adresse (réponse DHCPNAK) à un client. On laisse donc la gestion des refus à l'autre serveur. Par contre, il faut faire attention au sous-réseau géré par notre serveur, si une machine de ce sous réseau à déjà une adresse fournit par l'autre server DHCP, elle pourra envoyer des DHCPDISCOVER vers notre serveur pour renouveller son bail. Dans ce cas, notre serveur répondra DHCPNAK. Il est donc important de choisir un sous réseau petit, l'idéal étant de choisir un sous-réseau non géré par l'autre serveur DHCP.

En refusant d'assigner des adresses au machines dont on ne connait pas l'adresse MAC (elles seront déclarées dans la configuration) on ne risque pas d'assigner une adresse à la place de l'autre serveur. Cette configuration pour un serveur “non autoritaire” permet d'ignorer totalement les requêtes DHCP et ne fournir que le service de BOOTP.

Voici le fichier de configuration :

#
# DHCP Server Configuration file.
#   see /usr/share/doc/dhcp*/dhcpd.conf.sample
#
not authoritative;
boot-unknown-clients false;
ddns-update-style none;
ignore client-updates;

subnet 192.168.0.0 netmask 255.255.255.0 {

        option subnet-mask 255.255.255.0;
        option broadcast-address 192.168.0.255;
        option routers 192.168.0.1;
        option domain-name-servers 192.168.0.2, 192.168.0.3;
        option domain-name "example.org";

        # BOOTP Clients
}

On remarque qu'on ne definit pas de “range” allouable.

Déclarer des clients

Pour ajouter un client BOOTP, il faut insérer un bloc host dans le bloc subnet, en dessous du commentaire :

host qs22 {
        hardware ethernet 00:1A:64:B8:06:5A;
        fixed-address 192.168.0.4;
        filename "qs22.boot";
}

hardware ethernet : l'adresse MAC de la machine à booter
fixed-address : permet de définir l'adresse IP de la machine à booter. Le reste des informations de configuration réseau de la machine sera pris des options du bloc subnet.
filename: le chemin vers l'image de boot. Pour les PowerPC, il s'agit d'un fichier contenant le kernel et l'initrd.

Mettre en place le service TFTP pour les images de boot.

Le service TFTP (Trivial File Transfert Protocol) est fournit par le super serveur inetd ou xinetd. xinetd est un remplacement de inetd censé être supérieur. Comme il est par défault sur par mal de distributions, on va l'utiliser.

Sur ma Debian, xinetd n'était pas installé au profit de l'historique inetd :

# aptitude install xinetd tftpd

Ensuite, il faut l'activer en créant un fichier /etc/xinetd.d/tftp :

service tftp
{
        disable         = no
        socket_type     = dgram
        protocol        = udp
        wait            = yes
        user            = nobody
        server          = /usr/sbin/in.tftpd
        server_args     = /srv/tftp
}

La directive server_args indique le répertoire des fichiers servis par tftpd. C'est la configuration par défaut sur Debian, mais on peut utiliser l'historique /tftpboot:

# mkdir /srv/tftp

Enfin, on relance xinetd pour activer cette configuration :

# /etc/init.d/xinetd restart

On n'oublie pas non plus de copier l'image de boot dans /srv/tftp. Il ne reste plus qu'à booter la machine diskless sur le réseau.

Serveur GIT sour Debian

2009-11-06T16:45:35+00:00

Packages

# aptitude install git-core git-daemon-run

Configurer le git-daemon

Le truc tourne grâce à runit, un outil de gestion de services. La configuration des services gérés par runit est dans /etc/sv.

Runit

Après l'installation, une nouvelle entrée est disponible dans /etc/inittab, pour s'assurer que runit tourne tout le temps, s'il est stoppé, init le redémarrera (respawn):

#-- runit begin
SV:123456:respawn:/usr/sbin/runsvdir-start
#-- runit end

Pour l'activer, on doit demander à init de relire /etc/inittab, en lui envoyant le signal hangup:

# kill -HUP 1

Ensuite, on peut vérifier le status du daemon git, et le stopper pour le configurer:

# sv status git-daemon
# sv stop git-daemon
ok: down: git-daemon: 0s, normally up
# sv status git-daemon
down: git-daemon: 3s, normally up; run: log: (pid 24348) 369s

Configuration

Migration de subversion à git

# aptitude install git-svn

Linux

2011-07-05T15:17:42+00:00

Debian

OpenWRT

OpenWRT - Distribution Linux pour routeurs wifi
OpenWRT sur un Linksys WRT54GL – Doc pour flasher le routeur
OpenWRT customisé – Créer son image prête à l'emploi avec l'« Image Builder »

Maemo

Installer Maemo Scratchbox
Nokia N8x0 – tips

SystemRescueCD sur une clé USB

2009-08-27T17:57:26+00:00

linux, debian

SystemRescueCD est une micro distribution Linux basée sur Gentoo contenant plein d'outils de barbus. Il faut une clé de 256Mo minimum.

Le wiki de SystemRescueCD propose une méthode de création de clé USB qui n'a pas fonctionné chez moi. L'astuce est d'utiliser syslinux pour préparer la clé, ensuite, la méthode est la même.

Les paquets Debian suivant sont requis:

syslinux
mbr (Debian seulement)
dosfstools

Préparer la clé

Trouver le device correspondant

# dmesg
  Vendor: USB       Model: FLASHDISK         Rev: 2010
  Type:   Direct-Access                      ANSI SCSI revision: 00
usb-storage: device scan complete
SCSI device sda: 506880 512-byte hdwr sectors (260 MB)
sda: Write Protect is off
sda: Mode Sense: 43 00 00 00
sda: assuming drive cache: write through
SCSI device sda: 506880 512-byte hdwr sectors (260 MB)
sda: Write Protect is off
sda: Mode Sense: 43 00 00 00
sda: assuming drive cache: write through
 sda: sda1 sda2
sd 0:0:0:0: Attached scsi removable disk sda

Attention aux automonteurs (HAL/DBus) comme sous KDE par exemple, il faut qu'aucune partition de la clé ne soit montée, sinon ça ne va pas plaire au système lors du partitionnement/formatage :

# mount | grep sda
/dev/sda2 on /media/disk type ext2 (rw,nosuid,nodev,uhelper=hal)
# umount /media/disk

Partitionnement et formatage

On utilise les outils syslinux pour créer la partition bootable. mkdiskimage permet de creer un disque en fournissant le nombre de cylindres, têtes et secteurs. Les options utilisées permettent de créer l'équivalent d'un disque Zip, qui, selon la doc de syslinux, passe toutes les contraintes d'alignement de cylindres du BIOS. Voir là :

# mkdiskimage -4 /dev/sda 0 64 32

Cette commande crée la partition /dev/sda4 qui utilise tout l'espace disponible sur la clé.

Initialisation du MBR

Sous Debian, il existe le paquet mbr, qui fournit la commande install-mbr, pour initialiser le MBR :

# install-mbr /dev/sda

Sinon il faut prendre l'image du MBR vide fournie par syslinux dans /usr/lib/syslinux/mbr.bin :

# dd if=/usr/lib/syslinux/mbr.bin of=/dev/sda

Installation de SystemRescueCD sur la clé

Récupérer la dernière version sur http://www.sysresccd.org/Download

Monter l'ISO en loopback :

# mkdir /tmp/sysresccd
# mount -o loop /path/to/systemrescuecd-ARCH-VERS.iso /tmp/sysresccd

Monter la clé USB :

# mkdir /tmp/sysrescusb
# mount /dev/sda4 /tmp/sysrescusb

Copier les fichiers de l'ISO dans l'ordre :

# cp /tmp/sysresccd/syslinux/syslinux.cfg /tmp/sysrescusb/
# cp /tmp/sysresccd/sysrcd.dat /tmp/sysrescusb/
# cp -R /tmp/sysresccd/isolinux/* /tmp/sysrescusb/
# cp /tmp/sysresccd/bootdisk/* /tmp/sysrescusb/
# sync

Démonter :

# umount /tmp/sysresccd
# umount /tmp/sysrescusb

Rendre la clé bootable avec syslinux :

# syslinux /dev/sda4

Conclusion

Il suffit maintenant de rebooter sur la clé. Il faut bien sûr que le BIOS supporte de genre de boot. Parfois, il suffit que la clé soit branchée au démarrage de la machine pour que le BIOS offre la possibilité de booter dessus.

Voir aussi la documentation de SystemRescueCD pour l'utilisation du système.

Configuration wifi en WPA sous Debian

2009-08-27T18:03:32+00:00

debian, linux, wifi, reseau

Pour les explications, on part du fait que l'AP est propement configuré en WPA(2)-PSK. Voici les infos à connaître sur l'AP:

SSID du WLAN
Clé WPA (PSK Key)

Pour se connecter au réseau WLAN du routeur on a besoin de wpasupplicant et des wireless-tools :

# aptitude install wpasupplicant wireless-tools

La documentation importante à lire est /usr/share/doc/wpasupplicant/README.Debian.gz, qui explique la configuration spécifique du fichier /etc/network/interfaces pour le wifi.

Configuration en ligne de commande

La première chose à faire de trouver le nom de l'interface réseau de la carte wifi, un simple iwconfig sans argument :

# iwconfig
...
eth0      no wireless extensions.

eth1      unassociated  ESSID:off/any
          Mode:Managed  Channel=0  Access Point: Not-Associated
          Bit Rate:0 kb/s   Tx-Power=20 dBm   Sensitivity=8/0
          Retry limit:7   RTS thr:off   Fragment thr:off
          Encryption key:off
          Power Management:off
          Link Quality:0  Signal level:0  Noise level:0
          Rx invalid nwid:0  Rx invalid crypt:0  Rx invalid frag:0
          Tx excessive retries:0  Invalid misc:0   Missed beacon:0

...

iwconfig est l'équivalent de ifconfig pour les paramètres particuliers des interfaces wifi, il ne le remplace pas mais le complète.

On scanne les réseaux disponibles avec iwlist :

# iwlist eth1 scanning
eth1      Scan completed :
          Cell 01 - Address: 00:21:29:B5:D7:6F
                    ESSID:"mon_ssid"
                    Protocol:IEEE 802.11bg
                    Mode:Master
                    Frequency:2.462 GHz (Channel 11)
                    Encryption key:on
                    Bit Rates:1 Mb/s; 2 Mb/s; 5.5 Mb/s; 6 Mb/s; 9 Mb/s
                              11 Mb/s; 12 Mb/s; 18 Mb/s; 24 Mb/s; 36 Mb/s
                              48 Mb/s; 54 Mb/s
                    Quality=92/100  Signal level=-36 dBm
                    IE: IEEE 802.11i/WPA2 Version 1
                        Group Cipher : CCMP
                        Pairwise Ciphers (1) : CCMP
                        Authentication Suites (1) : PSK
                    Extra: Last beacon: 4ms ago

Ces informations permettent de configurer pour se connecter au point d'accès :

Le SSID
Le mode
Le canal

On règle donc ces paramètres avec “iwconfig” :

# iwconfig eth1 essid mon_ssid
# iwconfig eth1 mode managed
# iwconfig eth1 channel 11

Ensuite, on va créer une entrée pour le réseau auquel se connecter dans le fichier /etc/wpa_supplicant.conf, on utilise la commande wpa_passphrase pour encoder la clé :

# wpa_passphrase mon_ssid ma_passphrase_compliquee
network={
        ssid="mon_ssid"
        #psk="ma_passphrase_compliquee"

        psk=d2d0935c07414ec7c9360e6b0a60aea41d916935408e615f79e58fbc201ba8f8
}

Il faut copier coller le résultat dans /etc/wpa_supplicant.conf, on ajoute au passage quelques configurations adaptées au point d'accès (group et pairwise donnés par iwlist) :

network={
        ssid="mon_ssid"
        key_mgmt=WPA-PSK
        pairwise=CCMP
        group=CCMP
        #psk="ma_passphrase_compliquee"

        psk=d2d0935c07414ec7c9360e6b0a60aea41d916935408e615f79e58fbc201ba8f8
}

Dès que la configuration fonctionne, il faut rééditer le fichier pour supprimer la clé en clair (commentée de toute façon)

Enfin, on peut se connecter au point d'accès en lançant wpa_supplicant :

# wpa_supplicant -ieth1 -c/etc/wpa_supplicant.conf -Dwext
CTRL-EVENT-SCAN-RESULTS
Trying to associate with 00:21:29:b5:d7:6f (SSID='mon_ssid' freq=2462 MHz)
Associated with 00:21:29:b5:d7:6f
WPA: Key negotiation completed with 00:21:29:b5:d7:6f [PTK=CCMP GTK=CCMP]
CTRL-EVENT-CONNECTED - Connection to 00:21:29:b5:d7:6f completed (auth) [id=0 id_str=]

Normalement, wpa_supplicant tourne en tant que daemon. Il faut ajouter les options -B, -f et -P, pour avoir un truc propre avec pidfile et fichier de log :

# wpa_supplicant -B -ieth1 -c/etc/wpa_supplicant.conf -Dwext -P/var/run/wpa_supplicant.eth1.pid -f/var/log/wpa_supplicant.eth1.log

La dernière chose à faire est de configurer l'adresse IP et la route par défaut :

# ifconfig eth1 192.168.0.100 up
# route add default gw 192.168.0.1

ou en DHCP :

# dhclient3 eth1

Configuration du fichier "interfaces"

On peut indiquer un certain nombre d'options supplémentaires pour le WPA dans un bloc de configuration du fichier /etc/network/interfaces :

iface eth1 inet static
        wpa-ssid mon_ssid
        # plaintext passphrase
        wpa-psk ma_passphrase_compliquee
        wpa-key-mgmt WPA-PSK
        wpa-pairwise TKIP CCMP
        wpa-group TKIP CCMP
        wpa-proto WPA
        # static ip settings
        address 192.168.0.100
        netmask 255.255.255.0
        network 192.168.0.0
        broadcast 192.168.0.255
        gateway 192.168.0.1

On peut aussi utiliser le fichier de configuration de wpa_supplicant :

iface eth1 inet static
        wpa-conf /etc/wpa_supplicant.conf
        # static ip settings
        address 192.168.0.100
        netmask 255.255.255.0
        network 192.168.0.0
        broadcast 192.168.0.255
        gateway 192.168.0.1

Conclusion

La configuration du wifi sous Debian s'est bien simplifiée au cours temps, fini les scripts pre-up et compagnie.